<html>
<head>
  <link rel="stylesheet" type="text/css" href="main.css">
</head>
<body>
  <div class="main">
    <h1>Namespace: joker.core</h1>
    <span class="var-added">v1.0</span>
    <h2>Contents</h2>
    <ul>
      <li>
        <a href="#_summary">Summary</a>
      </li>
      <li>
        <a href="#_index">Index</a>
      </li>
      <li>
        <a href="#_constants">Constants</a>
      </li>
      <li>
        <a href="#_variables">Variables</a>
      </li>
      <li>
        <a href="#_functions">Functions, Macros, and Special Forms</a>
      </li>
    </ul>
    <h2 id="_summary">Summary</h2>
    <p class="var-docstr">Core library of Joker.</p>
    <h2 id="_index">Index</h2>
    <ul class="index">
      <li>
  <a href="#*">*</a>
</li>
<li>
  <a href="#*'">*&#39;</a>
</li>
<li>
  <a href="#*1">*1</a>
</li>
<li>
  <a href="#*2">*2</a>
</li>
<li>
  <a href="#*3">*3</a>
</li>
<li>
  <a href="#*assert*">*assert*</a>
</li>
<li>
  <a href="#*command-line-args*">*command-line-args*</a>
</li>
<li>
  <a href="#*e">*e</a>
</li>
<li>
  <a href="#*err*">*err*</a>
</li>
<li>
  <a href="#*file*">*file*</a>
</li>
<li>
  <a href="#*flush-on-newline*">*flush-on-newline*</a>
</li>
<li>
  <a href="#*in*">*in*</a>
</li>
<li>
  <a href="#*joker-version*">*joker-version*</a>
</li>
<li>
  <a href="#*linter-config*">*linter-config*</a>
</li>
<li>
  <a href="#*linter-mode*">*linter-mode*</a>
</li>
<li>
  <a href="#*main-file*">*main-file*</a>
</li>
<li>
  <a href="#*ns*">*ns*</a>
</li>
<li>
  <a href="#*out*">*out*</a>
</li>
<li>
  <a href="#*print-readably*">*print-readably*</a>
</li>
<li>
  <a href="#*repl*">*repl*</a>
</li>
<li>
  <a href="#+">+</a>
</li>
<li>
  <a href="#+'">+&#39;</a>
</li>
<li>
  <a href="#-">-</a>
</li>
<li>
  <a href="#-'">-&#39;</a>
</li>
<li>
  <a href="#->">-&gt;</a>
</li>
<li>
  <a href="#->>">-&gt;&gt;</a>
</li>
<li>
  <a href="#/">/</a>
</li>
<li>
  <a href="#<">&lt;</a>
</li>
<li>
  <a href="#<!">&lt;!</a>
</li>
<li>
  <a href="#<=">&lt;=</a>
</li>
<li>
  <a href="#=">=</a>
</li>
<li>
  <a href="#==">==</a>
</li>
<li>
  <a href="#>">&gt;</a>
</li>
<li>
  <a href="#>!">&gt;!</a>
</li>
<li>
  <a href="#>=">&gt;=</a>
</li>
<li>
  <a href="#NaN?">NaN?</a>
</li>
<li>
  <a href="#abs">abs</a>
</li>
<li>
  <a href="#alias">alias</a>
</li>
<li>
  <a href="#all-ns">all-ns</a>
</li>
<li>
  <a href="#alter-meta!">alter-meta!</a>
</li>
<li>
  <a href="#and">and</a>
</li>
<li>
  <a href="#any?">any?</a>
</li>
<li>
  <a href="#apply">apply</a>
</li>
<li>
  <a href="#array-map">array-map</a>
</li>
<li>
  <a href="#as->">as-&gt;</a>
</li>
<li>
  <a href="#assert">assert</a>
</li>
<li>
  <a href="#assoc">assoc</a>
</li>
<li>
  <a href="#assoc-in">assoc-in</a>
</li>
<li>
  <a href="#associative?">associative?</a>
</li>
<li>
  <a href="#atom">atom</a>
</li>
<li>
  <a href="#bigfloat">bigfloat</a>
</li>
<li>
  <a href="#bigfloat?">bigfloat?</a>
</li>
<li>
  <a href="#bigint">bigint</a>
</li>
<li>
  <a href="#binding">binding</a>
</li>
<li>
  <a href="#bit-and">bit-and</a>
</li>
<li>
  <a href="#bit-and-not">bit-and-not</a>
</li>
<li>
  <a href="#bit-clear">bit-clear</a>
</li>
<li>
  <a href="#bit-flip">bit-flip</a>
</li>
<li>
  <a href="#bit-not">bit-not</a>
</li>
<li>
  <a href="#bit-or">bit-or</a>
</li>
<li>
  <a href="#bit-set">bit-set</a>
</li>
<li>
  <a href="#bit-shift-left">bit-shift-left</a>
</li>
<li>
  <a href="#bit-shift-right">bit-shift-right</a>
</li>
<li>
  <a href="#bit-test">bit-test</a>
</li>
<li>
  <a href="#bit-xor">bit-xor</a>
</li>
<li>
  <a href="#boolean">boolean</a>
</li>
<li>
  <a href="#boolean?">boolean?</a>
</li>
<li>
  <a href="#bound?">bound?</a>
</li>
<li>
  <a href="#bounded-count">bounded-count</a>
</li>
<li>
  <a href="#butlast">butlast</a>
</li>
<li>
  <a href="#callable?">callable?</a>
</li>
<li>
  <a href="#case">case</a>
</li>
<li>
  <a href="#cast">cast</a>
</li>
<li>
  <a href="#chan">chan</a>
</li>
<li>
  <a href="#char">char</a>
</li>
<li>
  <a href="#char?">char?</a>
</li>
<li>
  <a href="#chunked-seq?">chunked-seq?</a>
</li>
<li>
  <a href="#class">class</a>
</li>
<li>
  <a href="#close!">close!</a>
</li>
<li>
  <a href="#coll?">coll?</a>
</li>
<li>
  <a href="#comment">comment</a>
</li>
<li>
  <a href="#comp">comp</a>
</li>
<li>
  <a href="#compare">compare</a>
</li>
<li>
  <a href="#complement">complement</a>
</li>
<li>
  <a href="#concat">concat</a>
</li>
<li>
  <a href="#cond">cond</a>
</li>
<li>
  <a href="#cond->">cond-&gt;</a>
</li>
<li>
  <a href="#cond->>">cond-&gt;&gt;</a>
</li>
<li>
  <a href="#condp">condp</a>
</li>
<li>
  <a href="#conj">conj</a>
</li>
<li>
  <a href="#cons">cons</a>
</li>
<li>
  <a href="#constantly">constantly</a>
</li>
<li>
  <a href="#contains?">contains?</a>
</li>
<li>
  <a href="#count">count</a>
</li>
<li>
  <a href="#counted?">counted?</a>
</li>
<li>
  <a href="#create-ns">create-ns</a>
</li>
<li>
  <a href="#cycle">cycle</a>
</li>
<li>
  <a href="#dec">dec</a>
</li>
<li>
  <a href="#dec'">dec&#39;</a>
</li>
<li>
  <a href="#declare">declare</a>
</li>
<li>
  <a href="#dedupe">dedupe</a>
</li>
<li>
  <a href="#default-data-readers">default-data-readers</a>
</li>
<li>
  <a href="#defmacro">defmacro</a>
</li>
<li>
  <a href="#defmethod">defmethod</a>
</li>
<li>
  <a href="#defmulti">defmulti</a>
</li>
<li>
  <a href="#defn">defn</a>
</li>
<li>
  <a href="#defn-">defn-</a>
</li>
<li>
  <a href="#defonce">defonce</a>
</li>
<li>
  <a href="#delay">delay</a>
</li>
<li>
  <a href="#delay?">delay?</a>
</li>
<li>
  <a href="#denominator">denominator</a>
</li>
<li>
  <a href="#deref">deref</a>
</li>
<li>
  <a href="#disj">disj</a>
</li>
<li>
  <a href="#dissoc">dissoc</a>
</li>
<li>
  <a href="#distinct">distinct</a>
</li>
<li>
  <a href="#distinct?">distinct?</a>
</li>
<li>
  <a href="#doall">doall</a>
</li>
<li>
  <a href="#dorun">dorun</a>
</li>
<li>
  <a href="#doseq">doseq</a>
</li>
<li>
  <a href="#dotimes">dotimes</a>
</li>
<li>
  <a href="#doto">doto</a>
</li>
<li>
  <a href="#double">double</a>
</li>
<li>
  <a href="#double?">double?</a>
</li>
<li>
  <a href="#drop">drop</a>
</li>
<li>
  <a href="#drop-last">drop-last</a>
</li>
<li>
  <a href="#drop-while">drop-while</a>
</li>
<li>
  <a href="#empty">empty</a>
</li>
<li>
  <a href="#empty?">empty?</a>
</li>
<li>
  <a href="#eval">eval</a>
</li>
<li>
  <a href="#even?">even?</a>
</li>
<li>
  <a href="#every-pred">every-pred</a>
</li>
<li>
  <a href="#every?">every?</a>
</li>
<li>
  <a href="#ex-cause">ex-cause</a>
</li>
<li>
  <a href="#ex-data">ex-data</a>
</li>
<li>
  <a href="#ex-info">ex-info</a>
</li>
<li>
  <a href="#ex-message">ex-message</a>
</li>
<li>
  <a href="#exit">exit</a>
</li>
<li>
  <a href="#false?">false?</a>
</li>
<li>
  <a href="#ffirst">ffirst</a>
</li>
<li>
  <a href="#filter">filter</a>
</li>
<li>
  <a href="#filterv">filterv</a>
</li>
<li>
  <a href="#find">find</a>
</li>
<li>
  <a href="#find-ns">find-ns</a>
</li>
<li>
  <a href="#find-var">find-var</a>
</li>
<li>
  <a href="#first">first</a>
</li>
<li>
  <a href="#flatten">flatten</a>
</li>
<li>
  <a href="#float?">float?</a>
</li>
<li>
  <a href="#flush">flush</a>
</li>
<li>
  <a href="#fn">fn</a>
</li>
<li>
  <a href="#fn?">fn?</a>
</li>
<li>
  <a href="#fnext">fnext</a>
</li>
<li>
  <a href="#fnil">fnil</a>
</li>
<li>
  <a href="#for">for</a>
</li>
<li>
  <a href="#force">force</a>
</li>
<li>
  <a href="#format">format</a>
</li>
<li>
  <a href="#frequencies">frequencies</a>
</li>
<li>
  <a href="#gensym">gensym</a>
</li>
<li>
  <a href="#get">get</a>
</li>
<li>
  <a href="#get-in">get-in</a>
</li>
<li>
  <a href="#get-method">get-method</a>
</li>
<li>
  <a href="#go">go</a>
</li>
<li>
  <a href="#group-by">group-by</a>
</li>
<li>
  <a href="#hash">hash</a>
</li>
<li>
  <a href="#hash-map">hash-map</a>
</li>
<li>
  <a href="#hash-set">hash-set</a>
</li>
<li>
  <a href="#ident?">ident?</a>
</li>
<li>
  <a href="#identical?">identical?</a>
</li>
<li>
  <a href="#identity">identity</a>
</li>
<li>
  <a href="#if-let">if-let</a>
</li>
<li>
  <a href="#if-not">if-not</a>
</li>
<li>
  <a href="#if-some">if-some</a>
</li>
<li>
  <a href="#in-ns">in-ns</a>
</li>
<li>
  <a href="#inc">inc</a>
</li>
<li>
  <a href="#inc'">inc&#39;</a>
</li>
<li>
  <a href="#indexed?">indexed?</a>
</li>
<li>
  <a href="#infinite?">infinite?</a>
</li>
<li>
  <a href="#instance?">instance?</a>
</li>
<li>
  <a href="#int">int</a>
</li>
<li>
  <a href="#int?">int?</a>
</li>
<li>
  <a href="#integer?">integer?</a>
</li>
<li>
  <a href="#interleave">interleave</a>
</li>
<li>
  <a href="#intern">intern</a>
</li>
<li>
  <a href="#interpose">interpose</a>
</li>
<li>
  <a href="#into">into</a>
</li>
<li>
  <a href="#iterate">iterate</a>
</li>
<li>
  <a href="#joker-version">joker-version</a>
</li>
<li>
  <a href="#juxt">juxt</a>
</li>
<li>
  <a href="#keep">keep</a>
</li>
<li>
  <a href="#keep-indexed">keep-indexed</a>
</li>
<li>
  <a href="#key">key</a>
</li>
<li>
  <a href="#keys">keys</a>
</li>
<li>
  <a href="#keyword">keyword</a>
</li>
<li>
  <a href="#keyword?">keyword?</a>
</li>
<li>
  <a href="#last">last</a>
</li>
<li>
  <a href="#lazy-cat">lazy-cat</a>
</li>
<li>
  <a href="#lazy-seq">lazy-seq</a>
</li>
<li>
  <a href="#let">let</a>
</li>
<li>
  <a href="#letfn">letfn</a>
</li>
<li>
  <a href="#line-seq">line-seq</a>
</li>
<li>
  <a href="#list">list</a>
</li>
<li>
  <a href="#list*">list*</a>
</li>
<li>
  <a href="#list?">list?</a>
</li>
<li>
  <a href="#load">load</a>
</li>
<li>
  <a href="#load-file">load-file</a>
</li>
<li>
  <a href="#load-string">load-string</a>
</li>
<li>
  <a href="#loaded-libs">loaded-libs</a>
</li>
<li>
  <a href="#loop">loop</a>
</li>
<li>
  <a href="#macroexpand">macroexpand</a>
</li>
<li>
  <a href="#macroexpand-1">macroexpand-1</a>
</li>
<li>
  <a href="#map">map</a>
</li>
<li>
  <a href="#map-indexed">map-indexed</a>
</li>
<li>
  <a href="#map?">map?</a>
</li>
<li>
  <a href="#mapcat">mapcat</a>
</li>
<li>
  <a href="#mapv">mapv</a>
</li>
<li>
  <a href="#max">max</a>
</li>
<li>
  <a href="#max-key">max-key</a>
</li>
<li>
  <a href="#memoize">memoize</a>
</li>
<li>
  <a href="#merge">merge</a>
</li>
<li>
  <a href="#merge-with">merge-with</a>
</li>
<li>
  <a href="#meta">meta</a>
</li>
<li>
  <a href="#methods">methods</a>
</li>
<li>
  <a href="#min">min</a>
</li>
<li>
  <a href="#min-key">min-key</a>
</li>
<li>
  <a href="#mod">mod</a>
</li>
<li>
  <a href="#name">name</a>
</li>
<li>
  <a href="#namespace">namespace</a>
</li>
<li>
  <a href="#nat-int?">nat-int?</a>
</li>
<li>
  <a href="#neg-int?">neg-int?</a>
</li>
<li>
  <a href="#neg?">neg?</a>
</li>
<li>
  <a href="#newline">newline</a>
</li>
<li>
  <a href="#next">next</a>
</li>
<li>
  <a href="#nfirst">nfirst</a>
</li>
<li>
  <a href="#nil?">nil?</a>
</li>
<li>
  <a href="#nnext">nnext</a>
</li>
<li>
  <a href="#not">not</a>
</li>
<li>
  <a href="#not-any?">not-any?</a>
</li>
<li>
  <a href="#not-empty">not-empty</a>
</li>
<li>
  <a href="#not-every?">not-every?</a>
</li>
<li>
  <a href="#not=">not=</a>
</li>
<li>
  <a href="#ns">ns</a>
</li>
<li>
  <a href="#ns-aliases">ns-aliases</a>
</li>
<li>
  <a href="#ns-interns">ns-interns</a>
</li>
<li>
  <a href="#ns-map">ns-map</a>
</li>
<li>
  <a href="#ns-name">ns-name</a>
</li>
<li>
  <a href="#ns-publics">ns-publics</a>
</li>
<li>
  <a href="#ns-refers">ns-refers</a>
</li>
<li>
  <a href="#ns-resolve">ns-resolve</a>
</li>
<li>
  <a href="#ns-sources">ns-sources</a>
</li>
<li>
  <a href="#ns-unalias">ns-unalias</a>
</li>
<li>
  <a href="#ns-unmap">ns-unmap</a>
</li>
<li>
  <a href="#nth">nth</a>
</li>
<li>
  <a href="#nthnext">nthnext</a>
</li>
<li>
  <a href="#nthrest">nthrest</a>
</li>
<li>
  <a href="#num">num</a>
</li>
<li>
  <a href="#number?">number?</a>
</li>
<li>
  <a href="#numerator">numerator</a>
</li>
<li>
  <a href="#odd?">odd?</a>
</li>
<li>
  <a href="#or">or</a>
</li>
<li>
  <a href="#parse-boolean">parse-boolean</a>
</li>
<li>
  <a href="#parse-double">parse-double</a>
</li>
<li>
  <a href="#parse-long">parse-long</a>
</li>
<li>
  <a href="#partial">partial</a>
</li>
<li>
  <a href="#partition">partition</a>
</li>
<li>
  <a href="#partition-all">partition-all</a>
</li>
<li>
  <a href="#partition-by">partition-by</a>
</li>
<li>
  <a href="#partitionv">partitionv</a>
</li>
<li>
  <a href="#partitionv-all">partitionv-all</a>
</li>
<li>
  <a href="#peek">peek</a>
</li>
<li>
  <a href="#pop">pop</a>
</li>
<li>
  <a href="#pos-int?">pos-int?</a>
</li>
<li>
  <a href="#pos?">pos?</a>
</li>
<li>
  <a href="#pprint">pprint</a>
</li>
<li>
  <a href="#pr">pr</a>
</li>
<li>
  <a href="#pr-err">pr-err</a>
</li>
<li>
  <a href="#pr-str">pr-str</a>
</li>
<li>
  <a href="#prefer-method">prefer-method</a>
</li>
<li>
  <a href="#prefers">prefers</a>
</li>
<li>
  <a href="#print">print</a>
</li>
<li>
  <a href="#print-err">print-err</a>
</li>
<li>
  <a href="#print-str">print-str</a>
</li>
<li>
  <a href="#printf">printf</a>
</li>
<li>
  <a href="#println">println</a>
</li>
<li>
  <a href="#println-err">println-err</a>
</li>
<li>
  <a href="#println-str">println-str</a>
</li>
<li>
  <a href="#prn">prn</a>
</li>
<li>
  <a href="#prn-err">prn-err</a>
</li>
<li>
  <a href="#prn-str">prn-str</a>
</li>
<li>
  <a href="#qualified-ident?">qualified-ident?</a>
</li>
<li>
  <a href="#qualified-keyword?">qualified-keyword?</a>
</li>
<li>
  <a href="#qualified-symbol?">qualified-symbol?</a>
</li>
<li>
  <a href="#quot">quot</a>
</li>
<li>
  <a href="#rand">rand</a>
</li>
<li>
  <a href="#rand-int">rand-int</a>
</li>
<li>
  <a href="#rand-nth">rand-nth</a>
</li>
<li>
  <a href="#random-sample">random-sample</a>
</li>
<li>
  <a href="#range">range</a>
</li>
<li>
  <a href="#ratio?">ratio?</a>
</li>
<li>
  <a href="#rational?">rational?</a>
</li>
<li>
  <a href="#re-find">re-find</a>
</li>
<li>
  <a href="#re-matches">re-matches</a>
</li>
<li>
  <a href="#re-pattern">re-pattern</a>
</li>
<li>
  <a href="#re-seq">re-seq</a>
</li>
<li>
  <a href="#read">read</a>
</li>
<li>
  <a href="#read-line">read-line</a>
</li>
<li>
  <a href="#read-string">read-string</a>
</li>
<li>
  <a href="#realized?">realized?</a>
</li>
<li>
  <a href="#reduce">reduce</a>
</li>
<li>
  <a href="#reduce-kv">reduce-kv</a>
</li>
<li>
  <a href="#reductions">reductions</a>
</li>
<li>
  <a href="#refer">refer</a>
</li>
<li>
  <a href="#refer-clojure">refer-clojure</a>
</li>
<li>
  <a href="#rem">rem</a>
</li>
<li>
  <a href="#remove">remove</a>
</li>
<li>
  <a href="#remove-all-methods">remove-all-methods</a>
</li>
<li>
  <a href="#remove-method">remove-method</a>
</li>
<li>
  <a href="#remove-ns">remove-ns</a>
</li>
<li>
  <a href="#repeat">repeat</a>
</li>
<li>
  <a href="#repeatedly">repeatedly</a>
</li>
<li>
  <a href="#replace">replace</a>
</li>
<li>
  <a href="#require">require</a>
</li>
<li>
  <a href="#requiring-resolve">requiring-resolve</a>
</li>
<li>
  <a href="#reset!">reset!</a>
</li>
<li>
  <a href="#reset-meta!">reset-meta!</a>
</li>
<li>
  <a href="#reset-vals!">reset-vals!</a>
</li>
<li>
  <a href="#resolve">resolve</a>
</li>
<li>
  <a href="#rest">rest</a>
</li>
<li>
  <a href="#reverse">reverse</a>
</li>
<li>
  <a href="#reversible?">reversible?</a>
</li>
<li>
  <a href="#rseq">rseq</a>
</li>
<li>
  <a href="#run!">run!</a>
</li>
<li>
  <a href="#second">second</a>
</li>
<li>
  <a href="#select-keys">select-keys</a>
</li>
<li>
  <a href="#seq">seq</a>
</li>
<li>
  <a href="#seq?">seq?</a>
</li>
<li>
  <a href="#seqable?">seqable?</a>
</li>
<li>
  <a href="#sequence">sequence</a>
</li>
<li>
  <a href="#sequential?">sequential?</a>
</li>
<li>
  <a href="#set">set</a>
</li>
<li>
  <a href="#set?">set?</a>
</li>
<li>
  <a href="#shuffle">shuffle</a>
</li>
<li>
  <a href="#simple-ident?">simple-ident?</a>
</li>
<li>
  <a href="#simple-keyword?">simple-keyword?</a>
</li>
<li>
  <a href="#simple-symbol?">simple-symbol?</a>
</li>
<li>
  <a href="#slurp">slurp</a>
</li>
<li>
  <a href="#some">some</a>
</li>
<li>
  <a href="#some->">some-&gt;</a>
</li>
<li>
  <a href="#some->>">some-&gt;&gt;</a>
</li>
<li>
  <a href="#some-fn">some-fn</a>
</li>
<li>
  <a href="#some?">some?</a>
</li>
<li>
  <a href="#sort">sort</a>
</li>
<li>
  <a href="#sort-by">sort-by</a>
</li>
<li>
  <a href="#special-symbol?">special-symbol?</a>
</li>
<li>
  <a href="#spit">spit</a>
</li>
<li>
  <a href="#split-at">split-at</a>
</li>
<li>
  <a href="#split-with">split-with</a>
</li>
<li>
  <a href="#splitv-at">splitv-at</a>
</li>
<li>
  <a href="#str">str</a>
</li>
<li>
  <a href="#string?">string?</a>
</li>
<li>
  <a href="#subs">subs</a>
</li>
<li>
  <a href="#subvec">subvec</a>
</li>
<li>
  <a href="#swap!">swap!</a>
</li>
<li>
  <a href="#swap-vals!">swap-vals!</a>
</li>
<li>
  <a href="#symbol">symbol</a>
</li>
<li>
  <a href="#symbol?">symbol?</a>
</li>
<li>
  <a href="#take">take</a>
</li>
<li>
  <a href="#take-last">take-last</a>
</li>
<li>
  <a href="#take-nth">take-nth</a>
</li>
<li>
  <a href="#take-while">take-while</a>
</li>
<li>
  <a href="#test">test</a>
</li>
<li>
  <a href="#the-ns">the-ns</a>
</li>
<li>
  <a href="#time">time</a>
</li>
<li>
  <a href="#trampoline">trampoline</a>
</li>
<li>
  <a href="#tree-seq">tree-seq</a>
</li>
<li>
  <a href="#true?">true?</a>
</li>
<li>
  <a href="#type">type</a>
</li>
<li>
  <a href="#unsigned-bit-shift-right">unsigned-bit-shift-right</a>
</li>
<li>
  <a href="#update">update</a>
</li>
<li>
  <a href="#update-in">update-in</a>
</li>
<li>
  <a href="#update-keys">update-keys</a>
</li>
<li>
  <a href="#update-vals">update-vals</a>
</li>
<li>
  <a href="#use">use</a>
</li>
<li>
  <a href="#val">val</a>
</li>
<li>
  <a href="#vals">vals</a>
</li>
<li>
  <a href="#var-get">var-get</a>
</li>
<li>
  <a href="#var-set">var-set</a>
</li>
<li>
  <a href="#var?">var?</a>
</li>
<li>
  <a href="#vary-meta">vary-meta</a>
</li>
<li>
  <a href="#vec">vec</a>
</li>
<li>
  <a href="#vector">vector</a>
</li>
<li>
  <a href="#vector?">vector?</a>
</li>
<li>
  <a href="#when">when</a>
</li>
<li>
  <a href="#when-first">when-first</a>
</li>
<li>
  <a href="#when-let">when-let</a>
</li>
<li>
  <a href="#when-not">when-not</a>
</li>
<li>
  <a href="#when-some">when-some</a>
</li>
<li>
  <a href="#while">while</a>
</li>
<li>
  <a href="#with-bindings">with-bindings</a>
</li>
<li>
  <a href="#with-bindings*">with-bindings*</a>
</li>
<li>
  <a href="#with-in-str">with-in-str</a>
</li>
<li>
  <a href="#with-meta">with-meta</a>
</li>
<li>
  <a href="#with-out-str">with-out-str</a>
</li>
<li>
  <a href="#with-redefs">with-redefs</a>
</li>
<li>
  <a href="#with-redefs-fn">with-redefs-fn</a>
</li>
<li>
  <a href="#xml-seq">xml-seq</a>
</li>
<li>
  <a href="#zero?">zero?</a>
</li>
<li>
  <a href="#zipmap">zipmap</a>
</li>

    </ul>
    <h2 id="_constants">Constants</h2>
    Constants are variables with <tt>:const true</tt> in their metadata. Joker currently does not recognize them as special; as such, it allows redefining them or their values.
    <ul>
      (None.)
    </ul>
    <h2 id="_variables">Variables</h2>
    <ul>
      <li>
  <h3 class="Variable" id="*1">*1</h3>
  <span class="var-kind Variable">Object</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"></pre>
  <p class="var-docstr">bound in a repl to the most recent value printed</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3629">source</a>
  
</li>
<li>
  <h3 class="Variable" id="*2">*2</h3>
  <span class="var-kind Variable">Object</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"></pre>
  <p class="var-docstr">bound in a repl to the second most recent value printed</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3633">source</a>
  
</li>
<li>
  <h3 class="Variable" id="*3">*3</h3>
  <span class="var-kind Variable">Object</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"></pre>
  <p class="var-docstr">bound in a repl to the third most recent value printed</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3637">source</a>
  
</li>
<li>
  <h3 class="Variable" id="*assert*">*assert*</h3>
  <span class="var-kind Variable">Boolean</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"></pre>
  <p class="var-docstr">When set to logical false, assert is a noop. Defaults to true.</p>
  
  
</li>
<li>
  <h3 class="Variable" id="*command-line-args*">*command-line-args*</h3>
  <span class="var-kind Variable">Seq</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"></pre>
  <p class="var-docstr">A sequence of the supplied command line arguments, or nil if<br>
  none were supplied</p>
  
  
</li>
<li>
  <h3 class="Variable" id="*e">*e</h3>
  <span class="var-kind Variable">Object</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"></pre>
  <p class="var-docstr">bound in a repl to the most recent exception caught by the repl</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3641">source</a>
  
</li>
<li>
  <h3 class="Variable" id="*err*">*err*</h3>
  <span class="var-kind Variable">IOWriter</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"></pre>
  <p class="var-docstr">A IOWriter object representing standard error for print operations.<br>
<br>
  Defaults to stderr.</p>
  
  
</li>
<li>
  <h3 class="Variable" id="*file*">*file*</h3>
  <span class="var-kind Variable">String</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"></pre>
  <p class="var-docstr">The path of the file being evaluated, as a String.<br>
<br>
  When there is no file, e.g. in the REPL, the value is not defined.</p>
  
  
</li>
<li>
  <h3 class="Variable" id="*flush-on-newline*">*flush-on-newline*</h3>
  <span class="var-kind Variable">Boolean</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"></pre>
  <p class="var-docstr">When set to true, output will be flushed whenever a newline is printed.<br>
<br>
    Defaults to true.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2109">source</a>
  
</li>
<li>
  <h3 class="Variable" id="*in*">*in*</h3>
  <span class="var-kind Variable">BufferedReader</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"></pre>
  <p class="var-docstr">A BufferedReader object representing standard input for read operations.<br>
<br>
  Defaults to stdin.</p>
  
  
</li>
<li>
  <h3 class="Variable" id="*joker-version*">*joker-version*</h3>
  <span class="var-kind Variable">ArrayMap</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"></pre>
  <p class="var-docstr">The version info for Clojure core, as a map containing :major :minor<br>
			:incremental and :qualifier keys. Feature releases may increment<br>
			:minor and/or :major, bugfix releases will increment :incremental.</p>
  
  
</li>
<li>
  <h3 class="Variable" id="*linter-config*">*linter-config*</h3>
  <span class="var-kind Variable">ArrayMap</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"></pre>
  <p class="var-docstr">Map of configuration key/value pairs for linter mode</p>
  
  
</li>
<li>
  <h3 class="Variable" id="*linter-mode*">*linter-mode*</h3>
  <span class="var-kind Variable">Boolean</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"></pre>
  <p class="var-docstr">true if Joker is running in linter mode</p>
  
  
</li>
<li>
  <h3 class="Variable" id="*main-file*">*main-file*</h3>
  <span class="var-kind Variable">String</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"></pre>
  <p class="var-docstr">The absolute path of &lt;filename&gt; on the command line, as a String.<br>
<br>
  When there is no file, e.g. in the REPL, the value is not defined.</p>
  
  
</li>
<li>
  <h3 class="Variable" id="*ns*">*ns*</h3>
  <span class="var-kind Variable">Namespace</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"></pre>
  <p class="var-docstr">A Namespace object representing the current namespace.</p>
  
  
</li>
<li>
  <h3 class="Variable" id="*out*">*out*</h3>
  <span class="var-kind Variable">IOWriter</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"></pre>
  <p class="var-docstr">A IOWriter object representing standard output for print operations.<br>
<br>
  Defaults to stdout.</p>
  
  
</li>
<li>
  <h3 class="Variable" id="*print-readably*">*print-readably*</h3>
  <span class="var-kind Variable">Boolean</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"></pre>
  <p class="var-docstr">When set to logical false, strings and characters will be printed with<br>
  non-alphanumeric characters converted to the appropriate escape sequences.<br>
<br>
  Defaults to true</p>
  
  
</li>
<li>
  <h3 class="Variable" id="*repl*">*repl*</h3>
  <span class="var-kind Variable">Boolean</span>
  <span class="var-added">v1.5</span>
  <pre class="var-usage"></pre>
  <p class="var-docstr">true if Joker is running in repl mode</p>
  
  
</li>
<li>
  <h3 class="Variable" id="default-data-readers">default-data-readers</h3>
  <span class="var-kind Variable">ArrayMap</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"></pre>
  <p class="var-docstr">Default map of data reader functions provided by Joker. May be<br>
  overridden by binding *data-readers*.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4288">source</a>
  
</li>

    </ul>
    <h2 id="_functions">Functions, Macros, and Special Forms</h2>
    <ul>
      <li>
  <h3 class="Function" id="*">*</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(*)</code><code class="hide">^Number (*)</code></div>
<div><code>(* x)</code><code class="hide">^Number (* ^Number x)</code></div>
<div><code>(* x y)</code><code class="hide">^Number (* ^Number x ^Number y)</code></div>
<div><code>(* x y &amp; more)</code><code class="hide">^Number (* ^Number x ^Number y &amp; more)</code></div>
</pre>
  <p class="var-docstr">Returns the product of nums. (*) returns 1. Does not auto-promote<br>
  ints, will overflow. See also: *&#39;</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L743">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="*'">*&#39;</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(*&#39;)</code><code class="hide">^Number (*&#39;)</code></div>
<div><code>(*&#39; x)</code><code class="hide">^Number (*&#39; ^Number x)</code></div>
<div><code>(*&#39; x y)</code><code class="hide">^Number (*&#39; ^Number x ^Number y)</code></div>
<div><code>(*&#39; x y &amp; more)</code><code class="hide">^Number (*&#39; ^Number x ^Number y &amp; more)</code></div>
</pre>
  <p class="var-docstr">Returns the product of nums. (*) returns 1. Supports arbitrary precision.<br>
  See also: *</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L733">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="+">+</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(+)</code><code class="hide">^Number (+)</code></div>
<div><code>(+ x)</code><code class="hide">^Number (+ ^Number x)</code></div>
<div><code>(+ x y)</code><code class="hide">^Number (+ ^Number x ^Number y)</code></div>
<div><code>(+ x y &amp; more)</code><code class="hide">^Number (+ ^Number x ^Number y &amp; more)</code></div>
</pre>
  <p class="var-docstr">Returns the sum of nums. (+) returns 0. Does not auto-promote<br>
  ints, will overflow. See also: +&#39;</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L723">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="+'">+&#39;</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(+&#39;)</code><code class="hide">^Number (+&#39;)</code></div>
<div><code>(+&#39; x)</code><code class="hide">^Number (+&#39; ^Number x)</code></div>
<div><code>(+&#39; x y)</code><code class="hide">^Number (+&#39; ^Number x ^Number y)</code></div>
<div><code>(+&#39; x y &amp; more)</code><code class="hide">^Number (+&#39; ^Number x ^Number y &amp; more)</code></div>
</pre>
  <p class="var-docstr">Returns the sum of nums. (+) returns 0. Supports arbitrary precision.<br>
  See also: +</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L713">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="-">-</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(- x)</code><code class="hide">^Number (- ^Number x)</code></div>
<div><code>(- x y)</code><code class="hide">^Number (- ^Number x ^Number y)</code></div>
<div><code>(- x y &amp; more)</code><code class="hide">^Number (- ^Number x ^Number y &amp; more)</code></div>
</pre>
  <p class="var-docstr">If no ys are supplied, returns the negation of x, else subtracts<br>
  the ys from x and returns the result. Does not auto-promote<br>
  ints, will overflow. See also: -&#39;</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L772">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="-'">-&#39;</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(-&#39; x)</code><code class="hide">^Number (-&#39; ^Number x)</code></div>
<div><code>(-&#39; x y)</code><code class="hide">^Number (-&#39; ^Number x ^Number y)</code></div>
<div><code>(-&#39; x y &amp; more)</code><code class="hide">^Number (-&#39; ^Number x ^Number y &amp; more)</code></div>
</pre>
  <p class="var-docstr">If no ys are supplied, returns the negation of x, else subtracts<br>
  the ys from x and returns the result. Supports arbitrary precision.<br>
  See also: -</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L762">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Macro" id="->">-&gt;</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(-&gt; x &amp; forms)</code></div>
</pre>
  <p class="var-docstr">Threads the expr through the forms. Inserts x as the<br>
  second item in the first form, making a list of it if it is not a<br>
  list already. If there are more forms, inserts the first form as the<br>
  second item in second form, etc.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1186">source</a>
  
</li>
<li>
  <h3 class="Macro" id="->>">-&gt;&gt;</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(-&gt;&gt; x &amp; forms)</code></div>
</pre>
  <p class="var-docstr">Threads the expr through the forms. Inserts x as the<br>
  last item in the first form, making a list of it if it is not a<br>
  list already. If there are more forms, inserts the first form as the<br>
  last item in second form, etc.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1204">source</a>
  
</li>
<li>
  <h3 class="Function" id="/">/</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(/ x)</code><code class="hide">^Number (/ ^Number x)</code></div>
<div><code>(/ x y)</code><code class="hide">^Number (/ ^Number x ^Number y)</code></div>
<div><code>(/ x y &amp; more)</code><code class="hide">^Number (/ ^Number x ^Number y &amp; more)</code></div>
</pre>
  <p class="var-docstr">If no denominators are supplied, returns 1/numerator,<br>
  else returns numerator divided by all of the denominators.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L753">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="<">&lt;</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(&lt; x)</code><code class="hide">^Boolean (&lt; ^Number x)</code></div>
<div><code>(&lt; x y)</code><code class="hide">^Boolean (&lt; ^Number x ^Number y)</code></div>
<div><code>(&lt; x y &amp; more)</code><code class="hide">^Boolean (&lt; ^Number x ^Number y &amp; more)</code></div>
</pre>
  <p class="var-docstr">Returns non-nil if nums are in monotonically increasing order,<br>
  otherwise false.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L656">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="<!">&lt;!</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(&lt;! ch)</code><code class="hide">(&lt;! ^Channel ch)</code></div>
</pre>
  <p class="var-docstr">Takes a value from ch.<br>
  Returns nil if ch is closed and nothing is available on ch.<br>
  Blocks if nothing is available on ch and ch is not closed.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4499">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="<=">&lt;=</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(&lt;= x)</code><code class="hide">^Boolean (&lt;= ^Number x)</code></div>
<div><code>(&lt;= x y)</code><code class="hide">^Boolean (&lt;= ^Number x ^Number y)</code></div>
<div><code>(&lt;= x y &amp; more)</code><code class="hide">^Boolean (&lt;= ^Number x ^Number y &amp; more)</code></div>
</pre>
  <p class="var-docstr">Returns non-nil if nums are in monotonically non-decreasing order,<br>
  otherwise false.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L782">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="=">=</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(= x)</code><code class="hide">^Boolean (= x)</code></div>
<div><code>(= x y)</code><code class="hide">^Boolean (= x y)</code></div>
<div><code>(= x y &amp; more)</code><code class="hide">^Boolean (= x y &amp; more)</code></div>
</pre>
  <p class="var-docstr">Equality. Returns true if x equals y, false if not. Works for nil, and compares<br>
  numbers and collections in a type-independent manner.  Immutable data<br>
  structures define = as a value, not an identity,<br>
  comparison.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L574">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="==">==</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(== x)</code><code class="hide">^Boolean (== ^Number x)</code></div>
<div><code>(== x y)</code><code class="hide">^Boolean (== ^Number x ^Number y)</code></div>
<div><code>(== x y &amp; more)</code><code class="hide">^Boolean (== ^Number x ^Number y &amp; more)</code></div>
</pre>
  <p class="var-docstr">Returns non-nil if nums all have the equivalent<br>
  value (type-independent), otherwise false</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L821">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id=">">&gt;</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(&gt; x)</code><code class="hide">^Boolean (&gt; ^Number x)</code></div>
<div><code>(&gt; x y)</code><code class="hide">^Boolean (&gt; ^Number x ^Number y)</code></div>
<div><code>(&gt; x y &amp; more)</code><code class="hide">^Boolean (&gt; ^Number x ^Number y &amp; more)</code></div>
</pre>
  <p class="var-docstr">Returns non-nil if nums are in monotonically decreasing order,<br>
  otherwise false.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L795">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id=">!">&gt;!</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(&gt;! ch val)</code><code class="hide">(&gt;! ^Channel ch val)</code></div>
</pre>
  <p class="var-docstr">Puts val into ch.<br>
  Throws an exception if val is nil.<br>
  Blocks if ch is full (no buffer space is available).<br>
  Returns true unless ch is already closed.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4507">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id=">=">&gt;=</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(&gt;= x)</code><code class="hide">^Boolean (&gt;= ^Number x)</code></div>
<div><code>(&gt;= x y)</code><code class="hide">^Boolean (&gt;= ^Number x ^Number y)</code></div>
<div><code>(&gt;= x y &amp; more)</code><code class="hide">^Boolean (&gt;= ^Number x ^Number y &amp; more)</code></div>
</pre>
  <p class="var-docstr">Returns non-nil if nums are in monotonically non-increasing order,<br>
  otherwise false.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L808">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="NaN?">NaN?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.5</span>
  <pre class="var-usage"><div><code>(NaN? s)</code><code class="hide">^Boolean (NaN? ^Number s)</code></div>
</pre>
  <p class="var-docstr">Returns true if num is NaN, else false.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4566">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="abs">abs</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.5</span>
  <pre class="var-usage"><div><code>(abs s)</code><code class="hide">^Number (abs ^Number s)</code></div>
</pre>
  <p class="var-docstr">Returns the absolute value of a.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4572">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="alias">alias</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(alias alias namespace-sym)</code><code class="hide">^Nil (alias ^Symbol alias namespace-sym)</code></div>
</pre>
  <p class="var-docstr">Add an alias in the current namespace to another<br>
  namespace. Arguments are two symbols: the alias to be used, and<br>
  the symbolic name of the target namespace. Use :as in the ns macro in preference<br>
  to calling this directly.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2398">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="all-ns">all-ns</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(all-ns)</code><code class="hide">^Seq (all-ns)</code></div>
</pre>
  <p class="var-docstr">Returns a sequence of all namespaces.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2257">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="alter-meta!">alter-meta!</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(alter-meta! ref f &amp; args)</code><code class="hide">(alter-meta! ^Ref ref ^Callable f &amp; args)</code></div>
</pre>
  <p class="var-docstr">Atomically sets the metadata for a namespace/var/atom to be:<br>
<br>
  (apply f its-current-meta args)<br>
<br>
  f must be free of side-effects</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1468">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Macro" id="and">and</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(and)</code></div>
<div><code>(and x)</code></div>
<div><code>(and x &amp; next)</code></div>
</pre>
  <p class="var-docstr">Evaluates exprs one at a time, from left to right. If a form<br>
  returns logical false (nil or false), and returns that value and<br>
  doesn&#39;t evaluate any of the other expressions, otherwise it returns<br>
  the value of the last expr. (and) returns true.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L605">source</a>
  
</li>
<li>
  <h3 class="Function" id="any?">any?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(any? x)</code></div>
</pre>
  <p class="var-docstr">Returns true given any argument.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L381">source</a>
  
</li>
<li>
  <h3 class="Function" id="apply">apply</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(apply f args)</code><code class="hide">(apply ^Callable f ^Seqable args)</code></div>
<div><code>(apply f x args)</code><code class="hide">(apply ^Callable f x ^Seqable args)</code></div>
<div><code>(apply f x y args)</code><code class="hide">(apply ^Callable f x y ^Seqable args)</code></div>
<div><code>(apply f x y z args)</code><code class="hide">(apply ^Callable f x y z ^Seqable args)</code></div>
<div><code>(apply f a b c d &amp; args)</code><code class="hide">(apply ^Callable f a b c d &amp; args)</code></div>
</pre>
  <p class="var-docstr">Applies fn f to the argument list formed by prepending intervening arguments to args.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L482">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="array-map">array-map</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(array-map &amp; keyvals)</code></div>
</pre>
  <p class="var-docstr">Constructs an array-map. If any keys are equal, they are handled as<br>
         if by repeated uses of assoc.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2466">source</a>
  
</li>
<li>
  <h3 class="Macro" id="as->">as-&gt;</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(as-&gt; expr name &amp; forms)</code></div>
</pre>
  <p class="var-docstr">Binds name to expr, evaluates the first form in the lexical context<br>
  of that binding, then binds name to that result, repeating for each<br>
  successive form, returning the result of the last form.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4218">source</a>
  
</li>
<li>
  <h3 class="Macro" id="assert">assert</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(assert x)</code></div>
<div><code>(assert x message)</code></div>
</pre>
  <p class="var-docstr">Evaluates expr and throws an exception if it does not evaluate to<br>
  logical true.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2897">source</a>
  
</li>
<li>
  <h3 class="Function" id="assoc">assoc</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(assoc map key val)</code></div>
<div><code>(assoc map key val &amp; kvs)</code></div>
</pre>
  <p class="var-docstr">`assoc[iate]. When applied to a map, returns a new map of the<br>
         same (hashed/sorted) type, that contains the mapping of key(s) to<br>
         val(s). When applied to a vector, returns a new vector that<br>
         contains val at index. Note - index must be &lt;= (count vector).</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L149">source</a>
  
</li>
<li>
  <h3 class="Function" id="assoc-in">assoc-in</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(assoc-in m ks v)</code><code class="hide">^Map (assoc-in ^Associative m ^Seqable ks v)</code></div>
</pre>
  <p class="var-docstr">Associates a value in a nested associative structure, where ks is a<br>
  sequence of keys and v is the new value and returns a new nested structure.<br>
  If any levels do not exist, hash-maps will be created.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3535">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="associative?">associative?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(associative? coll)</code><code class="hide">^Boolean (associative? coll)</code></div>
</pre>
  <p class="var-docstr">Returns true if coll implements Associative</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3604">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="atom">atom</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(atom x &amp; options)</code><code class="hide">^Atom (atom x &amp; options)</code></div>
</pre>
  <p class="var-docstr">Creates and returns an Atom with an initial value of x and zero or<br>
  more options (in any order):<br>
<br>
  :meta metadata-map<br>
<br>
  If metadata-map is supplied, it will become the metadata on the<br>
  atom.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1425">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="bigfloat">bigfloat</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(bigfloat x)</code><code class="hide">^BigFloat (bigfloat x)</code></div>
</pre>
  <p class="var-docstr">Coerce to BigFloat</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2073">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="bigfloat?">bigfloat?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(bigfloat? n)</code><code class="hide">^Boolean (bigfloat? n)</code></div>
</pre>
  <p class="var-docstr">Returns true if n is a BigFloat</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2049">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="bigint">bigint</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(bigint x)</code><code class="hide">^BigInt (bigint x)</code></div>
</pre>
  <p class="var-docstr">Coerce to BigInt</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2066">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Macro" id="binding">binding</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(binding bindings &amp; body)</code></div>
</pre>
  <p class="var-docstr">binding =&gt; var-symbol init-expr<br>
<br>
  Creates new bindings for the (already-existing) vars, with the<br>
  supplied initial values, executes the exprs in an implicit do, then<br>
  re-establishes the bindings that existed before.  The new bindings<br>
  are made in parallel (unlike let); all init-exprs are evaluated<br>
  before the vars are bound to their new values.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1390">source</a>
  
</li>
<li>
  <h3 class="Function" id="bit-and">bit-and</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(bit-and x y)</code><code class="hide">^Int (bit-and ^Int x ^Int y)</code></div>
<div><code>(bit-and x y &amp; more)</code><code class="hide">^Int (bit-and ^Int x ^Int y &amp; more)</code></div>
</pre>
  <p class="var-docstr">Bitwise and</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L889">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="bit-and-not">bit-and-not</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(bit-and-not x y)</code><code class="hide">^Int (bit-and-not ^Int x ^Int y)</code></div>
<div><code>(bit-and-not x y &amp; more)</code><code class="hide">^Int (bit-and-not ^Int x ^Int y &amp; more)</code></div>
</pre>
  <p class="var-docstr">Bitwise and with complement</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L910">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="bit-clear">bit-clear</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(bit-clear x n)</code><code class="hide">^Int (bit-clear ^Int x ^Int n)</code></div>
</pre>
  <p class="var-docstr">Clear bit at index n</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L917">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="bit-flip">bit-flip</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(bit-flip x n)</code><code class="hide">^Int (bit-flip ^Int x ^Int n)</code></div>
</pre>
  <p class="var-docstr">Flip bit at index n</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L927">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="bit-not">bit-not</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(bit-not x)</code><code class="hide">^Int (bit-not ^Int x)</code></div>
</pre>
  <p class="var-docstr">Bitwise complement</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L884">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="bit-or">bit-or</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(bit-or x y)</code><code class="hide">^Int (bit-or ^Int x ^Int y)</code></div>
<div><code>(bit-or x y &amp; more)</code><code class="hide">^Int (bit-or ^Int x ^Int y &amp; more)</code></div>
</pre>
  <p class="var-docstr">Bitwise or</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L896">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="bit-set">bit-set</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(bit-set x n)</code><code class="hide">^Int (bit-set ^Int x ^Int n)</code></div>
</pre>
  <p class="var-docstr">Set bit at index n</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L922">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="bit-shift-left">bit-shift-left</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(bit-shift-left x n)</code><code class="hide">^Int (bit-shift-left ^Int x ^Int n)</code></div>
</pre>
  <p class="var-docstr">Bitwise shift left</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L937">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="bit-shift-right">bit-shift-right</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(bit-shift-right x n)</code><code class="hide">^Int (bit-shift-right ^Int x ^Int n)</code></div>
</pre>
  <p class="var-docstr">Bitwise shift right</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L942">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="bit-test">bit-test</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(bit-test x n)</code><code class="hide">^Boolean (bit-test ^Int x ^Int n)</code></div>
</pre>
  <p class="var-docstr">Test bit at index n</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L932">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="bit-xor">bit-xor</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(bit-xor x y)</code><code class="hide">^Int (bit-xor ^Int x ^Int y)</code></div>
<div><code>(bit-xor x y &amp; more)</code><code class="hide">^Int (bit-xor ^Int x ^Int y &amp; more)</code></div>
</pre>
  <p class="var-docstr">Bitwise exclusive or</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L903">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="boolean">boolean</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(boolean x)</code><code class="hide">^Boolean (boolean x)</code></div>
</pre>
  <p class="var-docstr">Coerce to boolean</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2012">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="boolean?">boolean?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(boolean? x)</code></div>
</pre>
  <p class="var-docstr">Return true if x is a Boolean</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L375">source</a>
  
</li>
<li>
  <h3 class="Function" id="bound?">bound?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(bound? &amp; vars)</code><code class="hide">^Boolean (bound? &amp; vars)</code></div>
</pre>
  <p class="var-docstr">Returns true if all of the vars provided as arguments have any bound value.<br>
  Implies that deref&#39;ing the provided vars will succeed. Returns true if no vars are provided.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3088">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="bounded-count">bounded-count</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(bounded-count n coll)</code><code class="hide">^Int (bounded-count ^Number n coll)</code></div>
</pre>
  <p class="var-docstr">If coll is counted? returns its count, else will count at most the first n<br>
  elements of coll using its seq</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4062">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="butlast">butlast</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(butlast coll)</code></div>
</pre>
  <p class="var-docstr">Return a seq of all but the last item in coll, in linear time.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L212">source</a>
  
</li>
<li>
  <h3 class="Function" id="callable?">callable?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(callable? x)</code><code class="hide">^Boolean (callable? x)</code></div>
</pre>
  <p class="var-docstr">Returns true if x implements Callable. Note that many data structures<br>
  (e.g. sets and maps) implement Callable.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3593">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Macro" id="case">case</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(case expr &amp; clauses)</code></div>
</pre>
  <p class="var-docstr">Takes an expression, and a set of clauses.<br>
<br>
  Each clause can take the form of either:<br>
<br>
  test-expr result-expr<br>
<br>
  (test-expr ... test-expr)  result-expr<br>
<br>
  If the expression is equal to a value of<br>
  test-expr, the corresponding result-expr is returned. A single<br>
  default expression can follow the clauses, and its value will be<br>
  returned if no clause matches. If no default expression is provided<br>
  and no clause matches, an exception is thrown.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3872">source</a>
  
</li>
<li>
  <h3 class="Function" id="cast">cast</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(cast t x)</code><code class="hide">(cast ^Type t x)</code></div>
</pre>
  <p class="var-docstr">Throws an error if x is not of a type t, else returns x.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L261">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="chan">chan</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(chan)</code><code class="hide">^Channel (chan)</code></div>
<div><code>(chan n)</code><code class="hide">^Channel (chan ^Int n)</code></div>
</pre>
  <p class="var-docstr">Returns a new channel with an optional buffer of size n.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4493">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="char">char</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(char x)</code><code class="hide">^Char (char x)</code></div>
</pre>
  <p class="var-docstr">Coerce to char</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2006">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="char?">char?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(char? x)</code></div>
</pre>
  <p class="var-docstr">Returns true if x is a Char</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L123">source</a>
  
</li>
<li>
  <h3 class="Function" id="chunked-seq?">chunked-seq?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(chunked-seq? s)</code><code class="hide">^Boolean (chunked-seq? s)</code></div>
</pre>
  <p class="var-docstr">Always returns false because chunked sequences are not supported</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L512">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="class">class</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(class x)</code><code class="hide">^Type (class x)</code></div>
</pre>
  <p class="var-docstr">Returns the Type of x.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1314">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="close!">close!</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(close! ch)</code><code class="hide">(close! ^Channel ch)</code></div>
</pre>
  <p class="var-docstr">Closes a channel. The channel will no longer accept any puts (they<br>
  will be ignored). Data in the channel remains available for taking, until<br>
  exhausted, after which takes will return nil. If there are any<br>
  pending takes, they will be dispatched with nil. Closing a closed<br>
  channel is a no-op. Returns nil.<br>
<br>
  Logically closing happens after all puts have been delivered. Therefore, any<br>
  blocked puts will remain blocked until a taker releases them.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4516">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="coll?">coll?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(coll? x)</code><code class="hide">^Boolean (coll? x)</code></div>
</pre>
  <p class="var-docstr">Returns true if x implements Collection</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3576">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Macro" id="comment">comment</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(comment &amp; body)</code></div>
</pre>
  <p class="var-docstr">Ignores body, yields nil</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2784">source</a>
  
</li>
<li>
  <h3 class="Function" id="comp">comp</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(comp)</code><code class="hide">^Fn (comp)</code></div>
<div><code>(comp f)</code><code class="hide">^Fn (comp ^Callable f)</code></div>
<div><code>(comp f g)</code><code class="hide">^Fn (comp ^Callable f ^Callable g)</code></div>
<div><code>(comp f g h)</code><code class="hide">^Fn (comp ^Callable f ^Callable g ^Callable h)</code></div>
<div><code>(comp f1 f2 f3 &amp; fs)</code><code class="hide">^Fn (comp ^Callable f1 ^Callable f2 ^Callable f3 &amp; fs)</code></div>
</pre>
  <p class="var-docstr">Takes a set of functions and returns a fn that is the composition<br>
  of those fns.  The returned fn takes a variable number of args,<br>
  applies the rightmost of fns to the args, the next<br>
  fn (right-to-left) to the result, etc.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1489">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="compare">compare</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(compare x y)</code><code class="hide">^Int (compare x y)</code></div>
</pre>
  <p class="var-docstr">Comparator. Returns a negative number, zero, or a positive number<br>
  when x is logically &#39;less than&#39;, &#39;equal to&#39;, or &#39;greater than&#39;<br>
  y. Works for nil, and compares numbers and collections in a type-independent manner. x<br>
  must implement Comparable</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L597">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="complement">complement</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(complement f)</code><code class="hide">^Fn (complement ^Callable f)</code></div>
</pre>
  <p class="var-docstr">Takes a fn f and returns a fn that takes the same arguments as f,<br>
  has the same effects, if any, and returns the opposite truth value.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1007">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="concat">concat</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(concat)</code><code class="hide">^Seq (concat)</code></div>
<div><code>(concat x)</code><code class="hide">^Seq (concat ^Seqable x)</code></div>
<div><code>(concat x y)</code><code class="hide">^Seq (concat ^Seqable x ^Seqable y)</code></div>
<div><code>(concat x y &amp; zs)</code><code class="hide">^Seq (concat ^Seqable x ^Seqable y &amp; zs)</code></div>
</pre>
  <p class="var-docstr">Returns a lazy seq representing the concatenation of the elements in the supplied colls.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L518">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Macro" id="cond">cond</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(cond &amp; clauses)</code></div>
</pre>
  <p class="var-docstr">Takes a set of test/expr pairs. It evaluates each test one at a<br>
  time.  If a test returns logical true, cond evaluates and returns<br>
  the value of the corresponding expr and doesn&#39;t evaluate any of the<br>
  other tests or exprs. (cond) returns nil.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L435">source</a>
  
</li>
<li>
  <h3 class="Macro" id="cond->">cond-&gt;</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(cond-&gt; expr &amp; clauses)</code></div>
</pre>
  <p class="var-docstr">Takes an expression and a set of test/form pairs. Threads expr (via -&gt;)<br>
  through each form for which the corresponding test<br>
  expression is true. Note that, unlike cond branching, cond-&gt; threading does<br>
  not short circuit after the first true test expression.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4174">source</a>
  
</li>
<li>
  <h3 class="Macro" id="cond->>">cond-&gt;&gt;</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(cond-&gt;&gt; expr &amp; clauses)</code></div>
</pre>
  <p class="var-docstr">Takes an expression and a set of test/form pairs. Threads expr (via -&gt;&gt;)<br>
  through each form for which the corresponding test expression<br>
  is true.  Note that, unlike cond branching, cond-&gt;&gt; threading does not short circuit<br>
  after the first true test expression.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4196">source</a>
  
</li>
<li>
  <h3 class="Macro" id="condp">condp</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(condp pred expr &amp; clauses)</code></div>
</pre>
  <p class="var-docstr">Takes a binary predicate, an expression, and a set of clauses.<br>
  Each clause can take the form of either:<br>
<br>
  test-expr result-expr<br>
<br>
  test-expr :&gt;&gt; result-fn<br>
<br>
  Note :&gt;&gt; is an ordinary keyword.<br>
<br>
  For each clause, (pred test-expr expr) is evaluated. If it returns<br>
  logical true, the clause is a match. If a binary clause matches, the<br>
  result-expr is returned, if a ternary clause matches, its result-fn,<br>
  which must be a unary function, is called with the result of the<br>
  predicate as its argument, the result of that call being the return<br>
  value of condp. A single default expression can follow the clauses,<br>
  and its value will be returned if no clause matches. If no default<br>
  expression is provided and no clause matches, an<br>
  exception is thrown.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3693">source</a>
  
</li>
<li>
  <h3 class="Function" id="conj">conj</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(conj coll x)</code></div>
<div><code>(conj coll x &amp; xs)</code></div>
</pre>
  <p class="var-docstr">conj[oin]. Returns a new collection with the xs<br>
         &#39;added&#39;. (conj nil item) returns (item).  The &#39;addition&#39; may<br>
         happen at different &#39;places&#39; depending on the concrete type.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L65">source</a>
  
</li>
<li>
  <h3 class="Function" id="cons">cons</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(cons x seq)</code></div>
</pre>
  <p class="var-docstr">Returns a new seq where x is the first element and seq is<br>
         the rest.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L19">source</a>
  
</li>
<li>
  <h3 class="Function" id="constantly">constantly</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(constantly x)</code><code class="hide">^Fn (constantly x)</code></div>
</pre>
  <p class="var-docstr">Returns a function that takes any number of arguments and returns x.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1018">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="contains?">contains?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(contains? coll key)</code><code class="hide">^Boolean (contains? ^Gettable coll key)</code></div>
</pre>
  <p class="var-docstr">Returns true if key is present in the given collection, otherwise<br>
  returns false.  Note that for numerically indexed collections like<br>
  vectors, this tests if the numeric key is within the<br>
  range of indexes. &#39;contains?&#39; operates constant or logarithmic time;<br>
  it will not perform a linear search for a value.  See also &#39;some&#39;.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1043">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="count">count</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(count coll)</code><code class="hide">^Int (count coll)</code></div>
</pre>
  <p class="var-docstr">Returns the number of items in the collection. (count nil) returns<br>
  0.  Also works on strings</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L634">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="counted?">counted?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(counted? coll)</code><code class="hide">^Boolean (counted? coll)</code></div>
</pre>
  <p class="var-docstr">Returns true if coll implements count in constant time</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3614">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="create-ns">create-ns</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(create-ns sym)</code><code class="hide">^Namespace (create-ns ^Symbol sym)</code></div>
</pre>
  <p class="var-docstr">Create a new namespace named by the symbol if one doesn&#39;t already<br>
  exist, returns it or the already-existing namespace of the same<br>
  name.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2244">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="cycle">cycle</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(cycle coll)</code><code class="hide">^Seq (cycle ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">Returns a lazy (infinite!) sequence of repetitions of the items in coll.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1731">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="dec">dec</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(dec x)</code><code class="hide">^Number (dec ^Number x)</code></div>
</pre>
  <p class="var-docstr">Returns a number one less than num. Does not auto-promote<br>
  ints, will overflow. See also: dec&#39;</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L856">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="dec'">dec&#39;</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(dec&#39; x)</code><code class="hide">^Number (dec&#39; ^Number x)</code></div>
</pre>
  <p class="var-docstr">Returns a number one less than num. Supports arbitrary precision.<br>
  See also: dec</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L850">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Macro" id="declare">declare</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(declare &amp; names)</code></div>
</pre>
  <p class="var-docstr">defs the supplied var names with no bindings, useful for making forward declarations.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1837">source</a>
  
</li>
<li>
  <h3 class="Function" id="dedupe">dedupe</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(dedupe coll)</code><code class="hide">^Seq (dedupe ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">Returns a lazy sequence removing consecutive duplicates in coll.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4264">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Macro" id="defmacro">defmacro</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(defmacro name doc-string? attr-map? [params*] body)</code></div>
<div><code>(defmacro name doc-string? attr-map? ([params*] body) + attr-map?)</code></div>
</pre>
  <p class="var-docstr">Like defn, but the resulting function name is declared as a<br>
         macro and will be used as a macro by the compiler when it is<br>
         called.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L300">source</a>
  
</li>
<li>
  <h3 class="Macro" id="defmethod">defmethod</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(defmethod multifn dispatch-val &amp; fn-tail)</code></div>
</pre>
  <p class="var-docstr">Creates and installs a new method of multimethod associated with dispatch-value. </p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4413">source</a>
  
</li>
<li>
  <h3 class="Macro" id="defmulti">defmulti</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(defmulti name docstring? attr-map? dispatch-fn &amp; options)</code></div>
</pre>
  <p class="var-docstr">Creates a new multimethod with the associated dispatch function.<br>
  The docstring and attr-map are optional.<br>
<br>
  Options are key-value pairs and may be one of:<br>
<br>
  :default<br>
<br>
  The default dispatch value, defaults to :default<br>
<br>
  :hierarchy (UNSUPPORTED)<br>
<br>
  The value used for hierarchical dispatch (e.g. ::square is-a ::shape)<br>
<br>
  Hierarchies are type-like relationships that do not depend upon type<br>
  inheritance. By default Clojure&#39;s multimethods dispatch off of a<br>
  global hierarchy map.  However, a hierarchy relationship can be<br>
  created with the derive function used to augment the root ancestor<br>
  created with make-hierarchy.<br>
<br>
  Multimethods expect the value of the hierarchy option to be supplied as<br>
  a reference type e.g. a var (i.e. via the Var-quote dispatch macro #&#39;<br>
  or the var special form).</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4353">source</a>
  
</li>
<li>
  <h3 class="Macro" id="defn">defn</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(defn name doc-string? attr-map? [params*] prepost-map? body)</code></div>
<div><code>(defn name doc-string? attr-map? ([params*] prepost-map? body) + attr-map?)</code></div>
</pre>
  <p class="var-docstr">Same as (def name (fn [params* ] exprs*)) or (def<br>
         name (fn ([params* ] exprs*)+)) with any doc-string or attrs added<br>
         to the var metadata. prepost-map defines a map with optional keys<br>
         :pre and :post that contain collections of pre or post conditions.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L221">source</a>
  
</li>
<li>
  <h3 class="Macro" id="defn-">defn-</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(defn- name &amp; decls)</code></div>
</pre>
  <p class="var-docstr">same as defn, yielding non-public def</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2964">source</a>
  
</li>
<li>
  <h3 class="Macro" id="defonce">defonce</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(defonce name expr)</code></div>
</pre>
  <p class="var-docstr">defs name to have the value of the expr if the named var is not bound,<br>
  else expr is unevaluated</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3176">source</a>
  
</li>
<li>
  <h3 class="Macro" id="delay">delay</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(delay &amp; body)</code></div>
</pre>
  <p class="var-docstr">Takes a body of expressions and yields a Delay object that will<br>
  invoke the body only the first time it is forced (with force or deref/@), and<br>
  will cache the result and return it on all subsequent force<br>
  calls. See also - realized?</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L539">source</a>
  
</li>
<li>
  <h3 class="Function" id="delay?">delay?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(delay? x)</code><code class="hide">^Boolean (delay? x)</code></div>
</pre>
  <p class="var-docstr">returns true if x is a Delay created with delay</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L548">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="denominator">denominator</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(denominator r)</code><code class="hide">^Number (denominator ^Ratio r)</code></div>
</pre>
  <p class="var-docstr">Returns the denominator part of a Ratio.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2043">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="deref">deref</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(deref ref)</code><code class="hide">(deref ^Deref ref)</code></div>
</pre>
  <p class="var-docstr">Also reader macro: @var/@atom/@delay. When applied to a var or atom,<br>
  returns its current state. When applied to a delay, forces<br>
  it if not already forced.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1417">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="disj">disj</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(disj set)</code><code class="hide">^MapSet (disj ^Set set)</code></div>
<div><code>(disj set key)</code><code class="hide">^MapSet (disj ^Set set key)</code></div>
<div><code>(disj set key &amp; ks)</code><code class="hide">^MapSet (disj ^Set set key &amp; ks)</code></div>
</pre>
  <p class="var-docstr">disj[oin]. Returns a new set of the same (hashed/sorted) type, that<br>
  does not contain key(s).</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1073">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="dissoc">dissoc</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(dissoc map)</code><code class="hide">^Map (dissoc ^Map map)</code></div>
<div><code>(dissoc map key)</code><code class="hide">^Map (dissoc ^Map map key)</code></div>
<div><code>(dissoc map key &amp; ks)</code><code class="hide">^Map (dissoc ^Map map key &amp; ks)</code></div>
</pre>
  <p class="var-docstr">dissoc[iate]. Returns a new map of the same (hashed/sorted) type,<br>
  that does not contain a mapping for key(s).</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1060">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="distinct">distinct</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(distinct coll)</code><code class="hide">^Seq (distinct ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">Returns a lazy sequence of the elements of coll with duplicates removed.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3039">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="distinct?">distinct?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(distinct? x)</code><code class="hide">^Boolean (distinct? x)</code></div>
<div><code>(distinct? x y)</code><code class="hide">^Boolean (distinct? x y)</code></div>
<div><code>(distinct? x y &amp; more)</code><code class="hide">^Boolean (distinct? x y &amp; more)</code></div>
</pre>
  <p class="var-docstr">Returns true if no two of the arguments are =</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3100">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="doall">doall</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(doall coll)</code><code class="hide">^Seq (doall ^Seqable coll)</code></div>
<div><code>(doall n coll)</code><code class="hide">^Seq (doall ^Number n ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">When lazy sequences are produced via functions that have side<br>
  effects, any effects other than those needed to produce the first<br>
  element in the seq do not occur until the seq is consumed. doall can<br>
  be used to force any effects. Walks through the successive nexts of<br>
  the seq, retains the head and returns it, thus causing the entire<br>
  seq to reside in memory at one time.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1875">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="dorun">dorun</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(dorun coll)</code><code class="hide">^Nil (dorun ^Seqable coll)</code></div>
<div><code>(dorun n coll)</code><code class="hide">^Nil (dorun ^Number n ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">When lazy sequences are produced via functions that have side<br>
  effects, any effects other than those needed to produce the first<br>
  element in the seq do not occur until the seq is consumed. dorun can<br>
  be used to force any effects. Walks through the successive nexts of<br>
  the seq, does not retain the head and returns nil.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1861">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Macro" id="doseq">doseq</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(doseq seq-exprs &amp; body)</code></div>
</pre>
  <p class="var-docstr">Repeatedly executes body (presumably for side-effects) with<br>
  bindings and filtering as provided by &#34;for&#34;.  Does not retain<br>
  the head of the sequence. Returns nil.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1936">source</a>
  
</li>
<li>
  <h3 class="Macro" id="dotimes">dotimes</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(dotimes bindings &amp; body)</code></div>
</pre>
  <p class="var-docstr">bindings =&gt; name n<br>
<br>
  Repeatedly executes body (presumably for side-effects) with name<br>
  bound to integers from 0 through n-1.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1978">source</a>
  
</li>
<li>
  <h3 class="Macro" id="doto">doto</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(doto x &amp; forms)</code></div>
</pre>
  <p class="var-docstr">Evaluates x then calls all of the methods and functions with the<br>
  value of x supplied at the front of the given arguments.  The forms<br>
  are evaluated in order.  Returns x.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2169">source</a>
  
</li>
<li>
  <h3 class="Function" id="double">double</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(double x)</code><code class="hide">^Double (double ^Number x)</code></div>
</pre>
  <p class="var-docstr">Coerce to double</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2001">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="double?">double?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(double? x)</code><code class="hide">^Boolean (double? x)</code></div>
</pre>
  <p class="var-docstr">Return true if x is a Double</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1001">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="drop">drop</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(drop n coll)</code><code class="hide">^Seq (drop ^Number n ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">Returns a lazy sequence of all but the first n items in coll.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1692">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="drop-last">drop-last</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(drop-last s)</code><code class="hide">^Seq (drop-last ^Seqable s)</code></div>
<div><code>(drop-last n s)</code><code class="hide">^Seq (drop-last ^Number n ^Seqable s)</code></div>
</pre>
  <p class="var-docstr">Return a lazy sequence of all but the last n (default 1) items in coll</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1703">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="drop-while">drop-while</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(drop-while pred coll)</code><code class="hide">^Seq (drop-while ^Callable pred ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">Returns a lazy sequence of the items in coll starting from the first<br>
  item for which (pred item) returns logical false.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1719">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="empty">empty</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(empty coll)</code><code class="hide">^Collection (empty coll)</code></div>
</pre>
  <p class="var-docstr">Returns an empty collection of the same category as coll, or nil</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3082">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="empty?">empty?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(empty? coll)</code><code class="hide">^Boolean (empty? ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">Returns true if coll has no items - same as (not (seq coll)).<br>
  Please use the idiom (seq x) rather than (not (empty? x))</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3687">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="eval">eval</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(eval form)</code></div>
</pre>
  <p class="var-docstr">Evaluates the form data structure (not text!) and returns the result.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1931">source</a>
  
</li>
<li>
  <h3 class="Function" id="even?">even?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(even? n)</code><code class="hide">^Boolean (even? n)</code></div>
</pre>
  <p class="var-docstr">Returns true if n is even, throws an exception if n is not an integer</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L959">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="every-pred">every-pred</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(every-pred p)</code><code class="hide">^Fn (every-pred ^Callable p)</code></div>
<div><code>(every-pred p1 p2)</code><code class="hide">^Fn (every-pred ^Callable p1 ^Callable p2)</code></div>
<div><code>(every-pred p1 p2 p3)</code><code class="hide">^Fn (every-pred ^Callable p1 ^Callable p2 ^Callable p3)</code></div>
<div><code>(every-pred p1 p2 p3 &amp; ps)</code><code class="hide">^Fn (every-pred ^Callable p1 ^Callable p2 ^Callable p3 &amp; ps)</code></div>
</pre>
  <p class="var-docstr">Takes a set of predicates and returns a function f that returns true if all of its<br>
  composing predicates return a logical true value against all of its arguments, else it returns<br>
  false. Note that f is short-circuiting in that it will stop execution on the first<br>
  argument that triggers a logical false result against the original predicates.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4074">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="every?">every?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(every? pred coll)</code><code class="hide">^Boolean (every? ^Callable pred ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">Returns true if (pred x) is logical true for every x in coll, else<br>
  false.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1581">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="ex-cause">ex-cause</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(ex-cause ex)</code><code class="hide">^Error (ex-cause ex)</code></div>
</pre>
  <p class="var-docstr">Returns the cause of ex if ex is an ExInfo.<br>
  Otherwise returns nil.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2876">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="ex-data">ex-data</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(ex-data ex)</code><code class="hide">^Map (ex-data ex)</code></div>
</pre>
  <p class="var-docstr">Returns exception data (a map) if ex is an ExInfo.<br>
  Otherwise returns nil.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2868">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="ex-info">ex-info</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(ex-info msg map)</code></div>
<div><code>(ex-info msg map cause)</code></div>
</pre>
  <p class="var-docstr">Create an instance of ExInfo, an Error that carries a map of additional data.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L143">source</a>
  
</li>
<li>
  <h3 class="Function" id="ex-message">ex-message</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(ex-message ex)</code><code class="hide">^String (ex-message ex)</code></div>
</pre>
  <p class="var-docstr">Returns the message attached to ex if ex is an ExInfo.<br>
  Otherwise returns nil.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2884">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="exit">exit</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(exit)</code></div>
<div><code>(exit code)</code><code class="hide">(exit ^Int code)</code></div>
</pre>
  <p class="var-docstr">Causes the current program to exit with the given status code (defaults to 0).</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4559">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="false?">false?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(false? x)</code></div>
</pre>
  <p class="var-docstr">Returns true if x is the value false, false otherwise.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L363">source</a>
  
</li>
<li>
  <h3 class="Function" id="ffirst">ffirst</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(ffirst x)</code></div>
</pre>
  <p class="var-docstr">Same as (first (first x))</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L82">source</a>
  
</li>
<li>
  <h3 class="Function" id="filter">filter</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(filter pred coll)</code><code class="hide">^Seq (filter ^Callable pred ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">Returns a lazy sequence of the items in coll for which<br>
  (pred item) returns true. pred must be free of side-effects.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1653">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="filterv">filterv</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(filterv pred coll)</code><code class="hide">^Vec (filterv ^Callable pred coll)</code></div>
</pre>
  <p class="var-docstr">Returns a vector of the items in coll for which<br>
  (pred item) returns true. pred must be free of side-effects.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3924">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="find">find</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(find map key)</code><code class="hide">(find ^Associative map key)</code></div>
</pre>
  <p class="var-docstr">Returns the map entry for key, or nil if key not present.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1087">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="find-ns">find-ns</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(find-ns sym)</code><code class="hide">^Namespace (find-ns ^Symbol sym)</code></div>
</pre>
  <p class="var-docstr">Returns the namespace named by the symbol or nil if it doesn&#39;t exist.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2239">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="find-var">find-var</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(find-var sym)</code><code class="hide">^Var (find-var ^Symbol sym)</code></div>
</pre>
  <p class="var-docstr">Returns the global var named by the namespace-qualified symbol, or<br>
  nil if no var with that name.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1483">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="first">first</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(first coll)</code></div>
</pre>
  <p class="var-docstr">Returns the first item in the collection. Calls seq on its<br>
         argument. If coll is nil, returns nil.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L45">source</a>
  
</li>
<li>
  <h3 class="Function" id="flatten">flatten</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(flatten x)</code><code class="hide">^Seq (flatten x)</code></div>
</pre>
  <p class="var-docstr">Takes any nested combination of sequential things (lists, vectors,<br>
  etc.) and returns their contents as a single, flat sequence.<br>
  (flatten nil) returns an empty sequence.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3950">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="float?">float?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(float? n)</code><code class="hide">^Boolean (float? n)</code></div>
</pre>
  <p class="var-docstr">Returns true if n is a floating point number</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2054">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="flush">flush</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(flush)</code><code class="hide">^Nil (flush)</code></div>
</pre>
  <p class="var-docstr">Flushes the output stream that is the current value of<br>
  *out*</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2101">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Special form" id="fn">fn</h3>
  <span class="var-kind Special form">Special form</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(fn name? [params*] exprs*)</code></div>
<div><code>(fn name? ([params*] exprs*) +)</code></div>
</pre>
  <p class="var-docstr">params =&gt; positional-params* , or positional-params* &amp; next-param<br>
  positional-param =&gt; binding-form<br>
  next-param =&gt; binding-form<br>
  name =&gt; symbol<br>
<br>
  Defines a function</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2619">source</a>
  
</li>
<li>
  <h3 class="Function" id="fn?">fn?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(fn? x)</code><code class="hide">^Boolean (fn? x)</code></div>
</pre>
  <p class="var-docstr">Returns true if x is Fn, i.e. is an object created via fn.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3599">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="fnext">fnext</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(fnext x)</code></div>
</pre>
  <p class="var-docstr">Same as (first (next x))</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L93">source</a>
  
</li>
<li>
  <h3 class="Function" id="fnil">fnil</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(fnil f x)</code><code class="hide">^Fn (fnil ^Callable f x)</code></div>
<div><code>(fnil f x y)</code><code class="hide">^Fn (fnil ^Callable f x y)</code></div>
<div><code>(fnil f x y z)</code><code class="hide">^Fn (fnil ^Callable f x y z)</code></div>
</pre>
  <p class="var-docstr">Takes a function f, and returns a function that calls f, replacing<br>
  a nil first argument to f with the supplied value x. Higher arity<br>
  versions can replace arguments in the second and third<br>
  positions (y, z). Note that the function f can take any number of<br>
  arguments, not just the one(s) being nil-patched.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3829">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Macro" id="for">for</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(for seq-exprs body-expr)</code></div>
</pre>
  <p class="var-docstr">List comprehension. Takes a vector of one or more<br>
  binding-form/collection-expr pairs, each followed by zero or more<br>
  modifiers, and yields a lazy sequence of evaluations of expr.<br>
  Collections are iterated in a nested fashion, rightmost fastest,<br>
  and nested coll-exprs can refer to bindings created in prior<br>
  binding-forms.  Supported modifiers are: :let [binding-form expr ...],<br>
  :while test, :when test.<br>
<br>
  (take 100 (for [x (range 100000000) y (range 1000000) :while (&lt; y x)]  [x y]))</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2735">source</a>
  
</li>
<li>
  <h3 class="Function" id="force">force</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(force x)</code></div>
</pre>
  <p class="var-docstr">If x is a Delay, returns the (possibly cached) value of its expression, else returns x</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L554">source</a>
  
</li>
<li>
  <h3 class="Function" id="format">format</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(format fmt &amp; args)</code><code class="hide">^String (format ^String fmt &amp; args)</code></div>
</pre>
  <p class="var-docstr">Formats a string using fmt.Sprintf</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3115">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="frequencies">frequencies</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(frequencies coll)</code><code class="hide">^Map (frequencies coll)</code></div>
</pre>
  <p class="var-docstr">Returns a map from distinct items in coll to the number of times<br>
  they appear.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3983">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="gensym">gensym</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(gensym)</code><code class="hide">^Symbol (gensym)</code></div>
<div><code>(gensym prefix-string)</code><code class="hide">^Symbol (gensym ^String prefix-string)</code></div>
</pre>
  <p class="var-docstr">Returns a new symbol with a unique name. If a prefix string is<br>
  supplied, the name is prefix# where # is some unique number. If<br>
  prefix is not supplied, the prefix is &#39;G__&#39;.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L424">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="get">get</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(get map key)</code></div>
<div><code>(get map key not-found)</code></div>
</pre>
  <p class="var-docstr">Returns the value mapped to key, not-found or nil if key not present.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1052">source</a>
  
</li>
<li>
  <h3 class="Function" id="get-in">get-in</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(get-in m ks)</code><code class="hide">(get-in m ^Seqable ks)</code></div>
<div><code>(get-in m ks not-found)</code><code class="hide">(get-in m ^Seqable ks not-found)</code></div>
</pre>
  <p class="var-docstr">Returns the value in a nested associative structure,<br>
  where ks is a sequence of keys. Returns nil if the key<br>
  is not present, or the not-found value if supplied.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3517">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="get-method">get-method</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(get-method multifn dispatch-val)</code><code class="hide">^Fn (get-method multifn dispatch-val)</code></div>
</pre>
  <p class="var-docstr">Given a multimethod and a dispatch value, returns the dispatch fn<br>
  that would apply to that value, or nil if none apply and no default</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4451">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Macro" id="go">go</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(go &amp; body)</code></div>
</pre>
  <p class="var-docstr">Schedules the body to run inside a goroutine.<br>
  Immediately returns a channel which will receive the result of the body when<br>
  completed.<br>
  If exception is thrown inside the body, it will be caught and re-thrown upon<br>
  reading from the returned channel.<br>
<br>
  Joker is single threaded and uses the GIL (Global Interpreter Lock) to make sure<br>
  only one goroutine (including the root one) executes at the same time.<br>
  However, channel operations and some I/O functions (joker.http/send, joker.os/sh*, joker.os/exec,<br>
  and joker.time/sleep) release the GIL and allow other goroutines to run.<br>
  So using goroutines only makes sense if you do I/O (specifically, calling the above functions)<br>
  inside them. Also, note that a goroutine may never have a chance to run if the root goroutine<br>
  (or another goroutine) doesn&#39;t do any I/O or channel operations (&lt;! or &gt;!).</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4475">source</a>
  
</li>
<li>
  <h3 class="Function" id="group-by">group-by</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(group-by f coll)</code><code class="hide">^Map (group-by ^Callable f coll)</code></div>
</pre>
  <p class="var-docstr">Returns a map of the elements of coll keyed by the result of<br>
  f on each element. The value at each key will be a vector of the<br>
  corresponding elements, in the order they appeared in coll.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3959">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="hash">hash</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(hash x)</code><code class="hide">^Int (hash x)</code></div>
</pre>
  <p class="var-docstr">Returns the hash code of its argument.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2892">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="hash-map">hash-map</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(hash-map &amp; keyvals)</code></div>
</pre>
  <p class="var-docstr">keyval =&gt; key val<br>
         Returns a new hash map with supplied mappings.  If any keys are<br>
         equal, they are handled as if by repeated uses of assoc.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L279">source</a>
  
</li>
<li>
  <h3 class="Function" id="hash-set">hash-set</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(hash-set &amp; keys)</code></div>
</pre>
  <p class="var-docstr">Returns a new hash set with supplied keys.  Any equal keys are<br>
         handled as if by repeated uses of conj.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L287">source</a>
  
</li>
<li>
  <h3 class="Function" id="ident?">ident?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(ident? x)</code><code class="hide">^Boolean (ident? x)</code></div>
</pre>
  <p class="var-docstr">Return true if x is a symbol or keyword</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1150">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="identical?">identical?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(identical? x y)</code><code class="hide">^Boolean (identical? x y)</code></div>
</pre>
  <p class="var-docstr">Tests if 2 arguments are the same object</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L568">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="identity">identity</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(identity x)</code></div>
</pre>
  <p class="var-docstr">Returns its argument.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1024">source</a>
  
</li>
<li>
  <h3 class="Macro" id="if-let">if-let</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(if-let bindings then)</code></div>
<div><code>(if-let bindings then else &amp; oldform)</code></div>
</pre>
  <p class="var-docstr">bindings =&gt; binding-form test<br>
<br>
  If test is true, evaluates then with binding-form bound to the value of<br>
  test, if not, yields else</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1232">source</a>
  
</li>
<li>
  <h3 class="Macro" id="if-not">if-not</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(if-not test then)</code></div>
<div><code>(if-not test then else)</code></div>
</pre>
  <p class="var-docstr">Evaluates test. If logical false, evaluates and returns then expr,<br>
  otherwise else expr, if supplied, else nil.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L560">source</a>
  
</li>
<li>
  <h3 class="Macro" id="if-some">if-some</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(if-some bindings then)</code></div>
<div><code>(if-some bindings then else &amp; oldform)</code></div>
</pre>
  <p class="var-docstr">bindings =&gt; binding-form test<br>
<br>
  If test is not nil, evaluates then with binding-form bound to the<br>
  value of test, if not, yields else</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1276">source</a>
  
</li>
<li>
  <h3 class="Function" id="in-ns">in-ns</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(in-ns name)</code><code class="hide">^Namespace (in-ns ^Symbol name)</code></div>
</pre>
  <p class="var-docstr">Sets *ns* to the namespace named by the symbol, creating it if needed.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3190">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="inc">inc</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(inc x)</code><code class="hide">^Number (inc ^Number x)</code></div>
</pre>
  <p class="var-docstr">Returns a number one greater than num. Does not auto-promote<br>
  ints, will overflow. See also: inc&#39;</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L675">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="inc'">inc&#39;</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(inc&#39; x)</code><code class="hide">^Number (inc&#39; ^Number x)</code></div>
</pre>
  <p class="var-docstr">Returns a number one greater than num. Supports arbitrary precision.<br>
  See also: inc</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L669">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="indexed?">indexed?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(indexed? coll)</code><code class="hide">^Boolean (indexed? coll)</code></div>
</pre>
  <p class="var-docstr">Return true if coll implements Indexed, indicating efficient lookup by index</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3624">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="infinite?">infinite?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.5</span>
  <pre class="var-usage"><div><code>(infinite? s)</code><code class="hide">^Boolean (infinite? ^Number s)</code></div>
</pre>
  <p class="var-docstr">Returns true if num is negative or positive infinity, else false.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4578">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="instance?">instance?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(instance? c x)</code></div>
</pre>
  <p class="var-docstr">Evaluates x and tests if it is an instance of type<br>
         c. Returns true or false</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L111">source</a>
  
</li>
<li>
  <h3 class="Function" id="int">int</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(int x)</code><code class="hide">^Int (int x)</code></div>
</pre>
  <p class="var-docstr">Coerce to int</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L641">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="int?">int?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(int? x)</code><code class="hide">^Boolean (int? x)</code></div>
</pre>
  <p class="var-docstr">Return true if x is a fixed precision integer</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L974">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="integer?">integer?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(integer? n)</code><code class="hide">^Boolean (integer? n)</code></div>
</pre>
  <p class="var-docstr">Returns true if n is an integer</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L952">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="interleave">interleave</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(interleave)</code><code class="hide">^Seq (interleave)</code></div>
<div><code>(interleave c1)</code><code class="hide">^Seq (interleave ^Seqable c1)</code></div>
<div><code>(interleave c1 c2)</code><code class="hide">^Seq (interleave ^Seqable c1 ^Seqable c2)</code></div>
<div><code>(interleave c1 c2 &amp; colls)</code><code class="hide">^Seq (interleave ^Seqable c1 ^Seqable c2 &amp; colls)</code></div>
</pre>
  <p class="var-docstr">Returns a lazy seq of the first item in each coll, then the second etc.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2430">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="intern">intern</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(intern ns name)</code><code class="hide">^Var (intern ns ^Symbol name)</code></div>
<div><code>(intern ns name val)</code><code class="hide">^Var (intern ns ^Symbol name val)</code></div>
</pre>
  <p class="var-docstr">Finds or creates a var named by the symbol name in the namespace<br>
  ns (which can be a symbol or a namespace), setting its root binding<br>
  to val if supplied. The namespace must exist. The var will adopt any<br>
  metadata from the name symbol.  Returns the var.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2329">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="interpose">interpose</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(interpose sep coll)</code><code class="hide">^Seq (interpose sep ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">Returns a lazy seq of the elements of coll separated by sep.<br>
  Returns a stateful transducer when no collection is provided.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3075">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="into">into</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(into to from)</code></div>
</pre>
  <p class="var-docstr">Returns a new coll consisting of to-coll with all of the items of<br>
  from-coll conjoined.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3865">source</a>
  
</li>
<li>
  <h3 class="Function" id="iterate">iterate</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(iterate f x)</code><code class="hide">^Seq (iterate ^Callable f x)</code></div>
</pre>
  <p class="var-docstr">Returns a lazy sequence of x, (f x), (f (f x)) etc. f must be free of side-effects</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1757">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="joker-version">joker-version</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(joker-version)</code><code class="hide">^String (joker-version)</code></div>
</pre>
  <p class="var-docstr">Returns joker version as a printable string.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4315">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="juxt">juxt</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(juxt f)</code><code class="hide">^Fn (juxt ^Callable f)</code></div>
<div><code>(juxt f g)</code><code class="hide">^Fn (juxt ^Callable f ^Callable g)</code></div>
<div><code>(juxt f g h)</code><code class="hide">^Fn (juxt ^Callable f ^Callable g ^Callable h)</code></div>
<div><code>(juxt f g h &amp; fs)</code><code class="hide">^Fn (juxt ^Callable f ^Callable g ^Callable h &amp; fs)</code></div>
</pre>
  <p class="var-docstr">Takes a set of functions and returns a fn that is the juxtaposition<br>
  of those fns.  The returned fn takes a variable number of args, and<br>
  returns a vector containing the result of applying each fn to the<br>
  args (left-to-right).<br>
  ((juxt a b c) x) =&gt; [(a x) (b x) (c x)]</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1519">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="keep">keep</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(keep f coll)</code><code class="hide">^Seq (keep ^Callable f ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">Returns a lazy sequence of the non-nil results of (f item). Note,<br>
  this means false return values will be included.  f must be free of<br>
  side-effects.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4034">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="keep-indexed">keep-indexed</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(keep-indexed f coll)</code><code class="hide">^Seq (keep-indexed ^Callable f ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">Returns a lazy sequence of the non-nil results of (f index item). Note,<br>
  this means false return values will be included.  f must be free of<br>
  side-effects.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4047">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="key">key</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(key e)</code></div>
</pre>
  <p class="var-docstr">Returns the key of the map entry.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1116">source</a>
  
</li>
<li>
  <h3 class="Function" id="keys">keys</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(keys map)</code><code class="hide">^Seq (keys ^Map map)</code></div>
</pre>
  <p class="var-docstr">Returns a sequence of the map&#39;s keys, in the same order as (seq map).</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1106">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="keyword">keyword</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(keyword name)</code><code class="hide">^Keyword (keyword name)</code></div>
<div><code>(keyword ns name)</code><code class="hide">^Keyword (keyword ns name)</code></div>
</pre>
  <p class="var-docstr">Returns a Keyword with the given namespace and name.  Do not use :<br>
  in the keyword strings, it will be added automatically.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L452">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="keyword?">keyword?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(keyword? x)</code><code class="hide">^Boolean (keyword? x)</code></div>
</pre>
  <p class="var-docstr">Return true if x is a Keyword</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L412">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="last">last</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(last coll)</code></div>
</pre>
  <p class="var-docstr">Return the last item in coll, in linear time.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L204">source</a>
  
</li>
<li>
  <h3 class="Macro" id="lazy-cat">lazy-cat</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(lazy-cat &amp; colls)</code></div>
</pre>
  <p class="var-docstr">Expands to code which yields a lazy sequence of the concatenation<br>
  of the supplied colls.  Each coll expr is not evaluated until it is<br>
  needed.<br>
<br>
  (lazy-cat xs ys zs) === (concat (lazy-seq xs) (lazy-seq ys) (lazy-seq zs))</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2725">source</a>
  
</li>
<li>
  <h3 class="Macro" id="lazy-seq">lazy-seq</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(lazy-seq &amp; body)</code></div>
</pre>
  <p class="var-docstr">Takes a body of expressions that returns an ISeq or nil, and yields<br>
  a Seqable object that will invoke the body only the first time seq<br>
  is called, and will cache the result and return it on all subsequent<br>
  seq calls. See also - realized?</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L503">source</a>
  
</li>
<li>
  <h3 class="Special form" id="let">let</h3>
  <span class="var-kind Special form">Special form</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(let [bindings*] exprs*)</code></div>
</pre>
  <p class="var-docstr">binding =&gt; binding-form init-expr<br>
<br>
  Evaluates the exprs in a lexical context in which the symbols in<br>
  the binding-forms are bound to their respective init-exprs or parts<br>
  therein.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2587">source</a>
  
</li>
<li>
  <h3 class="Special form" id="letfn">letfn</h3>
  <span class="var-kind Special form">Special form</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(letfn [fnspecs*] exprs*)</code></div>
</pre>
  <p class="var-docstr">fnspec ==&gt; (fname [params*] exprs) or (fname ([params*] exprs)+)<br>
<br>
  Takes a vector of function specs and a body, and generates a set of<br>
  bindings of functions to their names. All of the names are available<br>
  in all of the definitions of the functions, as well as the body.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3815">source</a>
  
</li>
<li>
  <h3 class="Function" id="line-seq">line-seq</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(line-seq rdr)</code></div>
</pre>
  <p class="var-docstr">Returns the lines of text from rdr as a lazy sequence of strings.<br>
  rdr must be File or BufferedReader.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1825">source</a>
  
</li>
<li>
  <h3 class="Function" id="list">list</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(list &amp; items)</code></div>
</pre>
  <p class="var-docstr">Creates a new list containing the items.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L13">source</a>
  
</li>
<li>
  <h3 class="Function" id="list*">list*</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(list* args)</code><code class="hide">^Seq (list* ^Seqable args)</code></div>
<div><code>(list* a args)</code><code class="hide">^Seq (list* a ^Seqable args)</code></div>
<div><code>(list* a b args)</code><code class="hide">^Seq (list* a b ^Seqable args)</code></div>
<div><code>(list* a b c args)</code><code class="hide">^Seq (list* a b c ^Seqable args)</code></div>
<div><code>(list* a b c d &amp; more)</code><code class="hide">^Seq (list* a b c d &amp; more)</code></div>
</pre>
  <p class="var-docstr">Creates a new list containing the items prepended to the rest, the<br>
  last of which will be treated as a sequence.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L471">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="list?">list?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(list? x)</code><code class="hide">^Boolean (list? x)</code></div>
</pre>
  <p class="var-docstr">Returns true if x is a List</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3581">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="load">load</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(load &amp; libs)</code><code class="hide">^Nil (load &amp; libs)</code></div>
</pre>
  <p class="var-docstr">Loads code from libs, throwing error if cyclic dependency detected,<br>
  and ignoring libs already being loaded.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3499">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="load-file">load-file</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(load-file f)</code><code class="hide">^Nil (load-file ^String f)</code></div>
</pre>
  <p class="var-docstr">Loads code from file f. Does not protect against recursion.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3493">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="load-string">load-string</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(load-string s)</code><code class="hide">(load-string ^String s)</code></div>
</pre>
  <p class="var-docstr">Sequentially read and evaluate the set of forms contained in the<br>
  string</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2210">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="loaded-libs">loaded-libs</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(loaded-libs)</code><code class="hide">^MapSet (loaded-libs)</code></div>
</pre>
  <p class="var-docstr">Returns an UNSORTED set of symbols naming the currently loaded libs</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3487">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Special form" id="loop">loop</h3>
  <span class="var-kind Special form">Special form</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(loop [bindings*] exprs*)</code></div>
</pre>
  <p class="var-docstr">Evaluates the exprs in a lexical context in which the symbols in<br>
  the binding-forms are bound to their respective init-exprs or parts<br>
  therein. Acts as a recur target.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2684">source</a>
  
</li>
<li>
  <h3 class="Function" id="macroexpand">macroexpand</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(macroexpand form)</code></div>
</pre>
  <p class="var-docstr">Repeatedly calls macroexpand-1 on form until it no longer<br>
  represents a macro form, then returns it.  Note neither<br>
  macroexpand-1 nor macroexpand expand macros in subforms.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2199">source</a>
  
</li>
<li>
  <h3 class="Function" id="macroexpand-1">macroexpand-1</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(macroexpand-1 form)</code></div>
</pre>
  <p class="var-docstr">If form represents a macro form, returns its expansion, else returns form.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2193">source</a>
  
</li>
<li>
  <h3 class="Function" id="map">map</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(map f coll)</code><code class="hide">^Seq (map ^Callable f ^Seqable coll)</code></div>
<div><code>(map f c1 c2)</code><code class="hide">^Seq (map ^Callable f ^Seqable c1 ^Seqable c2)</code></div>
<div><code>(map f c1 c2 c3)</code><code class="hide">^Seq (map ^Callable f ^Seqable c1 ^Seqable c2 ^Seqable c3)</code></div>
<div><code>(map f c1 c2 c3 &amp; colls)</code><code class="hide">^Seq (map ^Callable f ^Seqable c1 ^Seqable c2 ^Seqable c3 &amp; colls)</code></div>
</pre>
  <p class="var-docstr">Returns a lazy sequence consisting of the result of applying f to the<br>
  set of first items of each coll, followed by applying f to the set<br>
  of second items in each coll, until any one of the colls is<br>
  exhausted.  Any remaining items in other colls are ignored. Function<br>
  f should accept number-of-colls arguments.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1615">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="map-indexed">map-indexed</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(map-indexed f coll)</code><code class="hide">^Seq (map-indexed ^Callable f ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">Returns a lazy sequence consisting of the result of applying f to 0<br>
  and the first item of coll, followed by applying f to 1 and the second<br>
  item in coll, etc, until coll is exhausted. Thus function f should<br>
  accept 2 arguments, index and item.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4021">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="map?">map?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(map? x)</code></div>
</pre>
  <p class="var-docstr">Returns true if x is a map</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L133">source</a>
  
</li>
<li>
  <h3 class="Function" id="mapcat">mapcat</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(mapcat f &amp; colls)</code><code class="hide">^Seq (mapcat ^Callable f &amp; colls)</code></div>
</pre>
  <p class="var-docstr">Returns the result of applying concat to the result of applying map<br>
  to f and colls.  Thus function f should return a collection.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1646">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="mapv">mapv</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(mapv f coll)</code><code class="hide">^Vec (mapv ^Callable f coll)</code></div>
<div><code>(mapv f c1 c2)</code><code class="hide">^Vec (mapv ^Callable f c1 c2)</code></div>
<div><code>(mapv f c1 c2 c3)</code><code class="hide">^Vec (mapv ^Callable f c1 c2 c3)</code></div>
<div><code>(mapv f c1 c2 c3 &amp; colls)</code><code class="hide">^Vec (mapv ^Callable f c1 c2 c3 &amp; colls)</code></div>
</pre>
  <p class="var-docstr">Returns a vector consisting of the result of applying f to the<br>
  set of first items of each coll, followed by applying f to the set<br>
  of second items in each coll, until any one of the colls is<br>
  exhausted.  Any remaining items in other colls are ignored. Function<br>
  f should accept number-of-colls arguments.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3908">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="max">max</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(max x)</code><code class="hide">^Number (max ^Number x)</code></div>
<div><code>(max x y)</code><code class="hide">^Number (max ^Number x ^Number y)</code></div>
<div><code>(max x y &amp; more)</code><code class="hide">^Number (max ^Number x ^Number y &amp; more)</code></div>
</pre>
  <p class="var-docstr">Returns the greatest of the nums.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L834">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="max-key">max-key</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(max-key k x)</code><code class="hide">(max-key ^Callable k x)</code></div>
<div><code>(max-key k x y)</code><code class="hide">(max-key ^Callable k x y)</code></div>
<div><code>(max-key k x y &amp; more)</code><code class="hide">(max-key ^Callable k x y &amp; more)</code></div>
</pre>
  <p class="var-docstr">Returns the x for which (k x), a number, is greatest.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3023">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="memoize">memoize</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(memoize f)</code><code class="hide">^Fn (memoize ^Callable f)</code></div>
</pre>
  <p class="var-docstr">Returns a memoized version of a referentially transparent function. The<br>
  memoized version of the function keeps a cache of the mapping from arguments<br>
  to results and, when calls with the same arguments are repeated often, has<br>
  higher performance at the expense of higher memory use.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3672">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="merge">merge</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(merge &amp; maps)</code><code class="hide">^Map (merge &amp; maps)</code></div>
</pre>
  <p class="var-docstr">Returns a map that consists of the rest of the maps conj-ed onto<br>
  the first.  If a key occurs in more than one map, the mapping from<br>
  the latter (left-to-right) will be the mapping in the result.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1781">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="merge-with">merge-with</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(merge-with f &amp; maps)</code><code class="hide">^Map (merge-with ^Callable f &amp; maps)</code></div>
</pre>
  <p class="var-docstr">Returns a map that consists of the rest of the maps conj-ed onto<br>
  the first.  If a key occurs in more than one map, the mapping(s)<br>
  from the latter (left-to-right) will be combined with the mapping in<br>
  the result by calling (f val-in-result val-in-latter).</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1790">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="meta">meta</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(meta obj)</code></div>
</pre>
  <p class="var-docstr">Returns the metadata of obj, returns nil if there is no metadata.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L165">source</a>
  
</li>
<li>
  <h3 class="Function" id="methods">methods</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(methods multifn)</code><code class="hide">^Map (methods multifn)</code></div>
</pre>
  <p class="var-docstr">Given a multimethod, returns a map of dispatch values -&gt; dispatch fns</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4443">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="min">min</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(min x)</code><code class="hide">^Number (min ^Number x)</code></div>
<div><code>(min x y)</code><code class="hide">^Number (min ^Number x ^Number y)</code></div>
<div><code>(min x y &amp; more)</code><code class="hide">^Number (min ^Number x ^Number y &amp; more)</code></div>
</pre>
  <p class="var-docstr">Returns the least of the nums.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L842">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="min-key">min-key</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(min-key k x)</code><code class="hide">(min-key ^Callable k x)</code></div>
<div><code>(min-key k x y)</code><code class="hide">(min-key ^Callable k x y)</code></div>
<div><code>(min-key k x y &amp; more)</code><code class="hide">(min-key ^Callable k x y &amp; more)</code></div>
</pre>
  <p class="var-docstr">Returns the x for which (k x), a number, is least.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3031">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="mod">mod</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(mod num div)</code><code class="hide">^Number (mod ^Number num ^Number div)</code></div>
</pre>
  <p class="var-docstr">Modulus of num and div. Truncates toward negative infinity.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2023">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="name">name</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(name x)</code><code class="hide">^String (name x)</code></div>
</pre>
  <p class="var-docstr">Returns the name String of a string, symbol, keyword or any Named object (e.g. File).</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1135">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="namespace">namespace</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(namespace x)</code><code class="hide">^String (namespace ^Named x)</code></div>
</pre>
  <p class="var-docstr">Returns the namespace String of a symbol or keyword, or nil if not present.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1143">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="nat-int?">nat-int?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(nat-int? x)</code><code class="hide">^Boolean (nat-int? x)</code></div>
</pre>
  <p class="var-docstr">Return true if x is a non-negative fixed precision integer</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L994">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="neg-int?">neg-int?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(neg-int? x)</code><code class="hide">^Boolean (neg-int? x)</code></div>
</pre>
  <p class="var-docstr">Return true if x is a negative fixed precision integer</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L987">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="neg?">neg?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(neg? x)</code><code class="hide">^Boolean (neg? ^Number x)</code></div>
</pre>
  <p class="var-docstr">Returns true if num is less than zero, else false</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L867">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="newline">newline</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(newline)</code><code class="hide">^Nil (newline)</code></div>
</pre>
  <p class="var-docstr">Writes a platform-specific newline to *out*</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2095">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="next">next</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(next coll)</code></div>
</pre>
  <p class="var-docstr">Returns a seq of the items after the first. Calls seq on its<br>
         argument.  If there are no more items, returns nil.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L51">source</a>
  
</li>
<li>
  <h3 class="Function" id="nfirst">nfirst</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(nfirst x)</code></div>
</pre>
  <p class="var-docstr">Same as (next (first x))</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L87">source</a>
  
</li>
<li>
  <h3 class="Function" id="nil?">nil?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(nil? x)</code></div>
</pre>
  <p class="var-docstr">Returns true if x is nil, false otherwise.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L294">source</a>
  
</li>
<li>
  <h3 class="Function" id="nnext">nnext</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(nnext x)</code></div>
</pre>
  <p class="var-docstr">Same as (next (next x))</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L98">source</a>
  
</li>
<li>
  <h3 class="Function" id="not">not</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(not x)</code><code class="hide">^Boolean (not x)</code></div>
</pre>
  <p class="var-docstr">Returns true if x is logical false, false otherwise.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L387">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="not-any?">not-any?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(not-any? pred coll)</code></div>
</pre>
  <p class="var-docstr">Returns false if (pred x) is logical true for any x in coll,<br>
         else true.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1608">source</a>
  
</li>
<li>
  <h3 class="Function" id="not-empty">not-empty</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(not-empty coll)</code><code class="hide">^Seqable (not-empty ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">If coll is empty, returns nil, else coll</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3095">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="not-every?">not-every?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(not-every? pred coll)</code></div>
</pre>
  <p class="var-docstr">Returns false if (pred x) is logical true for every x in<br>
         coll, else true.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1591">source</a>
  
</li>
<li>
  <h3 class="Function" id="not=">not=</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(not= x)</code><code class="hide">^Boolean (not= x)</code></div>
<div><code>(not= x y)</code><code class="hide">^Boolean (not= x y)</code></div>
<div><code>(not= x y &amp; more)</code><code class="hide">^Boolean (not= x y &amp; more)</code></div>
</pre>
  <p class="var-docstr">Same as (not (= obj1 obj2))</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L589">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Macro" id="ns">ns</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(ns name docstring? attr-map? references*)</code></div>
</pre>
  <p class="var-docstr">Sets *ns* to the namespace named by name (unevaluated), creating it<br>
  if needed.  references can be zero or more of:<br>
  (:require ...) (:use ...) (:load ...)<br>
  with the syntax of require/use/load<br>
  respectively, except the arguments are unevaluated and need not be<br>
  quoted. Use of ns is preferred to<br>
  individual calls to in-ns/require/use:<br>
<br>
  (ns foo.bar<br>
    (:require [my.lib1 :as lib1])<br>
    (:use [my.lib2]))</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3127">source</a>
  
</li>
<li>
  <h3 class="Function" id="ns-aliases">ns-aliases</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(ns-aliases ns)</code><code class="hide">^Map (ns-aliases ns)</code></div>
</pre>
  <p class="var-docstr">Returns a map of the aliases for the namespace.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2408">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="ns-interns">ns-interns</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(ns-interns ns)</code><code class="hide">^Map (ns-interns ns)</code></div>
</pre>
  <p class="var-docstr">Returns a map of the intern mappings for the namespace.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2315">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="ns-map">ns-map</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(ns-map ns)</code><code class="hide">^Map (ns-map ns)</code></div>
</pre>
  <p class="var-docstr">Returns a map of all the mappings for the namespace.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2286">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="ns-name">ns-name</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(ns-name ns)</code><code class="hide">^Symbol (ns-name ns)</code></div>
</pre>
  <p class="var-docstr">Returns the name of the namespace, a symbol.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2279">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="ns-publics">ns-publics</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(ns-publics ns)</code><code class="hide">^Map (ns-publics ns)</code></div>
</pre>
  <p class="var-docstr">Returns a map of the public intern mappings for the namespace.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2304">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="ns-refers">ns-refers</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(ns-refers ns)</code><code class="hide">^Map (ns-refers ns)</code></div>
</pre>
  <p class="var-docstr">Returns a map of the refer mappings for the namespace.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2388">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="ns-resolve">ns-resolve</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(ns-resolve ns sym)</code><code class="hide">^Var (ns-resolve ns ^Symbol sym)</code></div>
<div><code>(ns-resolve ns env sym)</code><code class="hide">^Var (ns-resolve ns ^Gettable env ^Symbol sym)</code></div>
</pre>
  <p class="var-docstr">Returns the var or type to which a symbol will be resolved in the<br>
  namespace (unless found in the environment), else nil.  Note that<br>
  if the symbol is fully qualified, the var/Type to which it resolves<br>
  need not be present in the namespace.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2447">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="ns-sources">ns-sources</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(ns-sources sources)</code><code class="hide">^Nil (ns-sources ^Map sources)</code></div>
</pre>
  <p class="var-docstr">Adds namespace mappings to the built-in variable *ns-sources*<br>
<br>
  The key/value pairs in the map define how to resolve external<br>
  dependencies. They are appended to the *ns-sources* vector in<br>
  arbitrary order; so, use separate invocations of this function<br>
  to add narrower keys before wider.<br>
<br>
  Each value is itself a map containing (primarily) a :url key whose<br>
  value is the URL of the resource. Only http:// and https:// are<br>
  currently supported; everything else is treated as a local<br>
  pathname. HTTP URLs are cached in $HOME/.jokerd/deps/.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3245">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="ns-unalias">ns-unalias</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(ns-unalias ns sym)</code><code class="hide">^Nil (ns-unalias ns ^Symbol sym)</code></div>
</pre>
  <p class="var-docstr">Removes the alias for the symbol from the namespace.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2415">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="ns-unmap">ns-unmap</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(ns-unmap ns sym)</code><code class="hide">^Nil (ns-unmap ns ^Symbol sym)</code></div>
</pre>
  <p class="var-docstr">Removes the mappings for the symbol from the namespace.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2293">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="nth">nth</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(nth coll index)</code><code class="hide">(nth coll ^Number index)</code></div>
<div><code>(nth coll index not-found)</code><code class="hide">(nth coll ^Number index not-found)</code></div>
</pre>
  <p class="var-docstr">Returns the value at the index. get returns nil if index out of<br>
  bounds, nth throws an exception unless not-found is supplied.  nth<br>
  also works, in O(n) time, for strings and sequences.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L647">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="nthnext">nthnext</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(nthnext coll n)</code><code class="hide">^Seq (nthnext ^Seqable coll ^Number n)</code></div>
</pre>
  <p class="var-docstr">Returns the nth next of coll, (seq coll) when n is 0.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1890">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="nthrest">nthrest</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(nthrest coll n)</code><code class="hide">^Seq (nthrest ^Seqable coll ^Number n)</code></div>
</pre>
  <p class="var-docstr">Returns the nth rest of coll, coll when n is 0.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1899">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="num">num</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(num x)</code><code class="hide">^Number (num ^Number x)</code></div>
</pre>
  <p class="var-docstr">Coerce to Number</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1996">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="number?">number?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(number? x)</code><code class="hide">^Boolean (number? x)</code></div>
</pre>
  <p class="var-docstr">Returns true if x is a Number</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2017">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="numerator">numerator</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(numerator r)</code><code class="hide">^Number (numerator ^Ratio r)</code></div>
</pre>
  <p class="var-docstr">Returns the numerator part of a Ratio.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2037">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="odd?">odd?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(odd? n)</code><code class="hide">^Boolean (odd? n)</code></div>
</pre>
  <p class="var-docstr">Returns true if n is odd, throws an exception if n is not an integer</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L968">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Macro" id="or">or</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(or)</code></div>
<div><code>(or x)</code></div>
<div><code>(or x &amp; next)</code></div>
</pre>
  <p class="var-docstr">Evaluates exprs one at a time, from left to right. If a form<br>
  returns a logical true value, or returns that value and doesn&#39;t<br>
  evaluate any of the other expressions, otherwise it returns the<br>
  value of the last expression. (or) returns nil.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L617">source</a>
  
</li>
<li>
  <h3 class="Function" id="parse-boolean">parse-boolean</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.5</span>
  <pre class="var-usage"><div><code>(parse-boolean s)</code><code class="hide">^Boolean (parse-boolean ^String s)</code></div>
</pre>
  <p class="var-docstr">Parses strings &#34;true&#34; or &#34;false&#34; and returns a boolean, or nil if invalid</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4584">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="parse-double">parse-double</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.5</span>
  <pre class="var-usage"><div><code>(parse-double s)</code><code class="hide">^Double (parse-double ^String s)</code></div>
</pre>
  <p class="var-docstr">Parses string with floating point components and return a Double value, or nil if parse fails.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4595">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="parse-long">parse-long</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.5</span>
  <pre class="var-usage"><div><code>(parse-long s)</code><code class="hide">^Number (parse-long ^String s)</code></div>
</pre>
  <p class="var-docstr">Parses string of decimal digits with optional leading -/+ and return an Int value, or nil if parse fails.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4601">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="partial">partial</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(partial f)</code><code class="hide">^Fn (partial ^Callable f)</code></div>
<div><code>(partial f arg1)</code><code class="hide">^Fn (partial ^Callable f arg1)</code></div>
<div><code>(partial f arg1 arg2)</code><code class="hide">^Fn (partial ^Callable f arg1 arg2)</code></div>
<div><code>(partial f arg1 arg2 arg3)</code><code class="hide">^Fn (partial ^Callable f arg1 arg2 arg3)</code></div>
<div><code>(partial f arg1 arg2 arg3 &amp; more)</code><code class="hide">^Fn (partial ^Callable f arg1 arg2 arg3 &amp; more)</code></div>
</pre>
  <p class="var-docstr">Takes a function f and fewer than the normal arguments to f, and<br>
  returns a fn that takes a variable number of additional args. When<br>
  called, the returned function calls f with args + additional args.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1556">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="partition">partition</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(partition n coll)</code><code class="hide">^Seq (partition ^Number n ^Seqable coll)</code></div>
<div><code>(partition n step coll)</code><code class="hide">^Seq (partition ^Number n ^Number step ^Seqable coll)</code></div>
<div><code>(partition n step pad coll)</code><code class="hide">^Seq (partition ^Number n ^Number step ^Seqable pad ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">Returns a lazy sequence of lists of n items each, at offsets step<br>
  apart. If step is not supplied, defaults to n, i.e. the partitions<br>
  do not overlap. If a pad collection is supplied, use its elements as<br>
  necessary to complete last partition upto n items. In case there are<br>
  not enough padding elements, return a partition with less than n items.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1908">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="partition-all">partition-all</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(partition-all n coll)</code><code class="hide">^Seq (partition-all ^Number n ^Seqable coll)</code></div>
<div><code>(partition-all n step coll)</code><code class="hide">^Seq (partition-all ^Number n ^Number step ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">Returns a lazy sequence of lists like partition, but may include<br>
  partitions with fewer than n items at the end.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3853">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="partition-by">partition-by</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(partition-by f coll)</code><code class="hide">^Seq (partition-by ^Callable f ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">Applies f to each value in coll, splitting it each time f returns a<br>
  new value.  Returns a lazy seq of partitions.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3971">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="partitionv">partitionv</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.5</span>
  <pre class="var-usage"><div><code>(partitionv n coll)</code></div>
<div><code>(partitionv n step coll)</code></div>
<div><code>(partitionv n step pad coll)</code></div>
</pre>
  <p class="var-docstr">Returns a lazy sequence of vectors of n items each, at offsets step<br>
  apart. If step is not supplied, defaults to n, i.e. the partitions<br>
  do not overlap. If a pad collection is supplied, use its elements as<br>
  necessary to complete last partition upto n items. In case there are<br>
  not enough padding elements, return a partition with less than n items.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4607">source</a>
  
</li>
<li>
  <h3 class="Function" id="partitionv-all">partitionv-all</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.5</span>
  <pre class="var-usage"><div><code>(partitionv-all n coll)</code></div>
<div><code>(partitionv-all n step coll)</code></div>
</pre>
  <p class="var-docstr">Returns a lazy sequence of vector partitions, but may include<br>
  partitions with fewer than n items at the end.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4630">source</a>
  
</li>
<li>
  <h3 class="Function" id="peek">peek</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(peek coll)</code><code class="hide">(peek ^Stack coll)</code></div>
</pre>
  <p class="var-docstr">For a list, same as first, for a vector, same as, but much<br>
  more efficient than, last. If the collection is empty, returns nil.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1029">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="pop">pop</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(pop coll)</code><code class="hide">(pop ^Stack coll)</code></div>
</pre>
  <p class="var-docstr">For a list, returns a new list without the first<br>
  item, for a vector, returns a new vector without the last item. If<br>
  the collection is empty, throws an exception.  Note - not the same<br>
  as next/butlast.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1035">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="pos-int?">pos-int?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(pos-int? x)</code><code class="hide">^Boolean (pos-int? x)</code></div>
</pre>
  <p class="var-docstr">Return true if x is a positive fixed precision integer</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L980">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="pos?">pos?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(pos? x)</code><code class="hide">^Boolean (pos? ^Number x)</code></div>
</pre>
  <p class="var-docstr">Returns true if num is greater than zero, else false</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L862">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="pprint">pprint</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(pprint x)</code><code class="hide">^Nil (pprint x)</code></div>
</pre>
  <p class="var-docstr">Pretty prints x to the output stream that is the current value of *out*.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2089">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="pr">pr</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(pr &amp; args)</code></div>
</pre>
  <p class="var-docstr">Prints the object(s) to the output stream that is the current value<br>
         of *out*.  Prints the object(s), separated by spaces if there is<br>
         more than one.  By default, pr and prn print in a way that objects<br>
         can be read by the reader</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2080">source</a>
  
</li>
<li>
  <h3 class="Function" id="pr-err">pr-err</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(pr-err &amp; xs)</code><code class="hide">^Nil (pr-err &amp; xs)</code></div>
</pre>
  <p class="var-docstr">pr to *err*</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2835">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="pr-str">pr-str</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(pr-str &amp; xs)</code><code class="hide">^String (pr-str &amp; xs)</code></div>
</pre>
  <p class="var-docstr">pr to a string, returning it</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2807">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="prefer-method">prefer-method</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(prefer-method multifn dispatch-val-x dispatch-val-y)</code></div>
</pre>
  <p class="var-docstr">Causes the multimethod to prefer matches of dispatch-val-x over dispatch-val-y<br>
   when there is a conflict</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4436">source</a>
  
</li>
<li>
  <h3 class="Function" id="prefers">prefers</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(prefers multifn)</code><code class="hide">^Map (prefers multifn)</code></div>
</pre>
  <p class="var-docstr">Given a multimethod, returns a map of preferred value -&gt; set of other values</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4463">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="print">print</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(print &amp; more)</code><code class="hide">^Nil (print &amp; more)</code></div>
</pre>
  <p class="var-docstr">Prints the object(s) to the output stream that is the current value<br>
  of *out*.  print and println produce output for human consumption.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2125">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="print-err">print-err</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(print-err &amp; xs)</code><code class="hide">^Nil (print-err &amp; xs)</code></div>
</pre>
  <p class="var-docstr">print to *err*</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2849">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="print-str">print-str</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(print-str &amp; xs)</code><code class="hide">^String (print-str &amp; xs)</code></div>
</pre>
  <p class="var-docstr">print to a string, returning it</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2821">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="printf">printf</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(printf fmt &amp; args)</code><code class="hide">^Nil (printf ^String fmt &amp; args)</code></div>
</pre>
  <p class="var-docstr">Prints formatted output, as per format</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3121">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="println">println</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(println &amp; more)</code><code class="hide">^Nil (println &amp; more)</code></div>
</pre>
  <p class="var-docstr">Same as print followed by (newline)</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2133">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="println-err">println-err</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(println-err &amp; xs)</code><code class="hide">^Nil (println-err &amp; xs)</code></div>
</pre>
  <p class="var-docstr">println to *err*</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2856">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="println-str">println-str</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(println-str &amp; xs)</code><code class="hide">^String (println-str &amp; xs)</code></div>
</pre>
  <p class="var-docstr">println to a string, returning it</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2828">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="prn">prn</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(prn &amp; more)</code><code class="hide">^Nil (prn &amp; more)</code></div>
</pre>
  <p class="var-docstr">Same as pr followed by (newline). Observes *flush-on-newline*</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2116">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="prn-err">prn-err</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(prn-err &amp; xs)</code><code class="hide">^Nil (prn-err &amp; xs)</code></div>
</pre>
  <p class="var-docstr">prn to *err*</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2842">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="prn-str">prn-str</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(prn-str &amp; xs)</code><code class="hide">^String (prn-str &amp; xs)</code></div>
</pre>
  <p class="var-docstr">prn to a string, returning it</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2814">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="qualified-ident?">qualified-ident?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(qualified-ident? x)</code><code class="hide">^Boolean (qualified-ident? x)</code></div>
</pre>
  <p class="var-docstr">Return true if x is a symbol or keyword with a namespace</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1161">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="qualified-keyword?">qualified-keyword?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(qualified-keyword? x)</code><code class="hide">^Boolean (qualified-keyword? x)</code></div>
</pre>
  <p class="var-docstr">Return true if x is a keyword with a namespace</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1181">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="qualified-symbol?">qualified-symbol?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(qualified-symbol? x)</code><code class="hide">^Boolean (qualified-symbol? x)</code></div>
</pre>
  <p class="var-docstr">Return true if x is a symbol with a namespace</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1171">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="quot">quot</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(quot num div)</code><code class="hide">^Number (quot ^Number num ^Number div)</code></div>
</pre>
  <p class="var-docstr">quot[ient] of dividing numerator by denominator.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L872">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="rand">rand</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(rand)</code><code class="hide">^Double (rand)</code></div>
<div><code>(rand n)</code><code class="hide">^Double (rand ^Number n)</code></div>
</pre>
  <p class="var-docstr">Returns a random floating point number between 0 (inclusive) and<br>
  n (default 1) (exclusive).</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2952">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="rand-int">rand-int</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(rand-int n)</code><code class="hide">^Int (rand-int ^Number n)</code></div>
</pre>
  <p class="var-docstr">Returns a random integer between 0 (inclusive) and n (exclusive).</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2959">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="rand-nth">rand-nth</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(rand-nth coll)</code></div>
</pre>
  <p class="var-docstr">Return a random element of the (sequential) collection. Will have<br>
  the same performance characteristics as nth for the given<br>
  collection.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4007">source</a>
  
</li>
<li>
  <h3 class="Function" id="random-sample">random-sample</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(random-sample prob coll)</code><code class="hide">^Seq (random-sample ^Number prob ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">Returns items from coll with random probability of prob (0.0 -<br>
  1.0).</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4273">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="range">range</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(range)</code><code class="hide">^Seq (range)</code></div>
<div><code>(range end)</code><code class="hide">^Seq (range ^Number end)</code></div>
<div><code>(range start end)</code><code class="hide">^Seq (range ^Number start ^Number end)</code></div>
<div><code>(range start end step)</code><code class="hide">^Seq (range ^Number start ^Number end ^Number step)</code></div>
</pre>
  <p class="var-docstr">Returns a lazy seq of nums from start (inclusive) to end<br>
  (exclusive), by step, where start defaults to 0, step to 1, and end to<br>
  infinity. When step is equal to 0, returns an infinite sequence of<br>
  start. When start is equal to end, returns empty list.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1762">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="ratio?">ratio?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(ratio? n)</code><code class="hide">^Boolean (ratio? n)</code></div>
</pre>
  <p class="var-docstr">Returns true if n is a Ratio</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2032">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="rational?">rational?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(rational? n)</code><code class="hide">^Boolean (rational? n)</code></div>
</pre>
  <p class="var-docstr">Returns true if n is a rational number</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2060">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="re-find">re-find</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(re-find re s)</code><code class="hide">(re-find ^Regex re ^String s)</code></div>
</pre>
  <p class="var-docstr">Returns the leftmost regex match, if any, of string to pattern.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2935">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="re-matches">re-matches</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(re-matches re s)</code><code class="hide">(re-matches ^Regex re ^String s)</code></div>
</pre>
  <p class="var-docstr">Returns the match, if any, of string to pattern.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2941">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="re-pattern">re-pattern</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(re-pattern s)</code><code class="hide">^Regex (re-pattern s)</code></div>
</pre>
  <p class="var-docstr">Returns an instance of Regex</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2920">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="re-seq">re-seq</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(re-seq re s)</code><code class="hide">^Seq (re-seq ^Regex re ^String s)</code></div>
</pre>
  <p class="var-docstr">Returns a sequence of successive matches of pattern in string</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2929">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="read">read</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(read)</code></div>
<div><code>(read reader)</code></div>
</pre>
  <p class="var-docstr">Reads the next object from reader (defaults to *in*)</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2140">source</a>
  
</li>
<li>
  <h3 class="Function" id="read-line">read-line</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(read-line)</code></div>
</pre>
  <p class="var-docstr">Reads the next line from *in*. Returns nil if an error (such as EOF) is detected.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2146">source</a>
  
</li>
<li>
  <h3 class="Function" id="read-string">read-string</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(read-string s)</code></div>
</pre>
  <p class="var-docstr">Reads one object from the string s.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2152">source</a>
  
</li>
<li>
  <h3 class="Function" id="realized?">realized?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(realized? x)</code><code class="hide">^Boolean (realized? ^Pending x)</code></div>
</pre>
  <p class="var-docstr">Returns true if a value has been produced for a delay or lazy sequence.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4169">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="reduce">reduce</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(reduce f coll)</code><code class="hide">(reduce ^Callable f coll)</code></div>
<div><code>(reduce f val coll)</code><code class="hide">(reduce ^Callable f val coll)</code></div>
</pre>
  <p class="var-docstr">f should be a function of 2 arguments. If val is not supplied,<br>
  returns the result of applying f to the first 2 items in coll, then<br>
  applying f to that result and the 3rd item, etc. If coll contains no<br>
  items, f must accept no arguments as well, and reduce returns the<br>
  result of calling f with no arguments.  If coll has only 1 item, it<br>
  is returned and f is not called.  If val is supplied, returns the<br>
  result of applying f to val and the first item in coll, then<br>
  applying f to that result and the 2nd item, etc. If coll contains no<br>
  items, returns val and f is not called.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L681">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="reduce-kv">reduce-kv</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(reduce-kv f init coll)</code><code class="hide">(reduce-kv ^Callable f init coll)</code></div>
</pre>
  <p class="var-docstr">Reduces an associative collection. f should be a function of 3<br>
  arguments. Returns the result of applying f to init, the first key<br>
  and the first value in coll, then applying f to that result and the<br>
  2nd key and value, etc. If coll contains no entries, returns init<br>
  and f is not called. Note that reduce-kv is supported on vectors,<br>
  where the keys will be the ordinals.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1326">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="reductions">reductions</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(reductions f coll)</code><code class="hide">^Seq (reductions ^Callable f ^Seqable coll)</code></div>
<div><code>(reductions f init coll)</code><code class="hide">^Seq (reductions ^Callable f init ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">Returns a lazy seq of the intermediate values of the reduction (as<br>
  per reduce) of coll by f, starting with init.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3992">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="refer">refer</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(refer ns-sym &amp; filters)</code><code class="hide">^Nil (refer ^Symbol ns-sym &amp; filters)</code></div>
</pre>
  <p class="var-docstr">refers to all public vars of ns, subject to filters.<br>
  filters can include at most one each of:<br>
<br>
  :exclude list-of-symbols<br>
  :only list-of-symbols<br>
  :rename map-of-fromsymbol-tosymbol<br>
<br>
  For each public interned var in the namespace named by the symbol,<br>
  adds a mapping from the name of the var to the var to the current<br>
  namespace.  Throws an exception if name is already mapped to<br>
  something else in the current namespace. Filters can be used to<br>
  select a subset, via inclusion or exclusion, or to provide a mapping<br>
  to a symbol different from the var&#39;s name, in order to prevent<br>
  clashes. Use :use in the ns macro in preference to calling this directly.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2346">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Macro" id="refer-clojure">refer-clojure</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(refer-clojure &amp; filters)</code></div>
</pre>
  <p class="var-docstr">Same as (refer &#39;joker.core &lt;filters&gt;)</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3170">source</a>
  
</li>
<li>
  <h3 class="Function" id="rem">rem</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(rem num div)</code><code class="hide">^Number (rem ^Number num ^Number div)</code></div>
</pre>
  <p class="var-docstr">remainder of dividing numerator by denominator.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L878">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="remove">remove</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(remove pred coll)</code><code class="hide">^Seq (remove ^Callable pred ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">Returns a lazy sequence of the items in coll for which<br>
  (pred item) returns false. pred must be free of side-effects.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1665">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="remove-all-methods">remove-all-methods</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(remove-all-methods multifn)</code></div>
</pre>
  <p class="var-docstr">Removes all of the methods of multimethod.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4421">source</a>
  
</li>
<li>
  <h3 class="Function" id="remove-method">remove-method</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(remove-method multifn dispatch-val)</code></div>
</pre>
  <p class="var-docstr">Removes the method of multimethod associated with dispatch-value.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4430">source</a>
  
</li>
<li>
  <h3 class="Function" id="remove-ns">remove-ns</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(remove-ns sym)</code><code class="hide">^Namespace (remove-ns ^Symbol sym)</code></div>
</pre>
  <p class="var-docstr">Removes the namespace named by the symbol. Use with caution.<br>
  Cannot be used to remove the clojure namespace.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2251">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="repeat">repeat</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(repeat x)</code><code class="hide">^Seq (repeat x)</code></div>
<div><code>(repeat n x)</code><code class="hide">^Seq (repeat ^Number n x)</code></div>
</pre>
  <p class="var-docstr">Returns a lazy (infinite!, or length n if supplied) sequence of xs.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1751">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="repeatedly">repeatedly</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(repeatedly f)</code><code class="hide">^Seq (repeatedly ^Callable f)</code></div>
<div><code>(repeatedly n f)</code><code class="hide">^Seq (repeatedly ^Number n ^Callable f)</code></div>
</pre>
  <p class="var-docstr">Takes a function of no args, presumably with side effects, and<br>
  returns an infinite (or length n if supplied) lazy sequence of calls<br>
  to it</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3067">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="replace">replace</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(replace smap coll)</code><code class="hide">(replace ^Associative smap ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">Given a map of replacement pairs and a vector/collection, returns a<br>
  vector/seq with any elements = a key in smap replaced with the<br>
  corresponding val in smap.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3053">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="require">require</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(require &amp; args)</code><code class="hide">^Nil (require &amp; args)</code></div>
</pre>
  <p class="var-docstr">Loads libs, skipping any that are already loaded. Each argument is<br>
  either a libspec that identifies a lib, a prefix list that<br>
  identifies multiple libs whose names share a common prefix, or a<br>
  flag that modifies how all the identified libs are<br>
  loaded. Use :require in the ns macro in preference to calling this<br>
  directly.<br>
<br>
  Libs<br>
<br>
  A &#39;lib&#39; is a named set of resources in *classpath* whose contents<br>
  define a library of Clojure code. Lib names are symbols and each lib<br>
  is associated with a Clojure namespace and a Joker package that<br>
  share its name. A lib&#39;s name also locates its root directory within<br>
  *classpath* using its package name to classpath-relative path<br>
  mapping. All resources in a lib should be contained in the directory<br>
  structure under its root directory.  All definitions a lib makes<br>
  should be in its associated namespace.<br>
<br>
  &#39;require loads a lib by loading its root resource. The root resource<br>
  path is derived from the lib name in the following manner: Consider<br>
  a lib named by the symbol &#39;x.y.z; it has the root directory<br>
  &lt;*classpath*&gt;/x/y/, and its root resource is<br>
  &lt;*classpath*&gt;/x/y/z.clj. The root resource should contain code to<br>
  create the lib&#39;s namespace (usually by using the ns macro) and load<br>
  any additional lib resources.<br>
<br>
  Libspecs<br>
<br>
  A libspec is a lib name or a vector containing a lib name followed<br>
  by options expressed as sequential keywords and arguments.<br>
<br>
  Recognized options:<br>
  :as takes a symbol as its argument and makes that symbol an alias to the<br>
    lib&#39;s namespace in the current namespace.<br>
  :refer takes a list of symbols to refer from the namespace or the :all<br>
    keyword to bring in all public vars.<br>
<br>
  Prefix Lists<br>
<br>
  It&#39;s common for Clojure code to depend on several libs whose names have<br>
  the same prefix. When specifying libs, prefix lists can be used to reduce<br>
  repetition. A prefix list contains the shared prefix followed by libspecs<br>
  with the shared prefix removed from the lib names. After removing the<br>
  prefix, the names that remain must not contain any periods.<br>
<br>
  Flags<br>
<br>
  A flag is a keyword.<br>
  Recognized flags: :reload, :reload-all, :verbose<br>
  :reload forces loading of all the identified libs even if they are<br>
    already loaded<br>
  :reload-all implies :reload and also forces loading of all libs that the<br>
    identified libs directly or indirectly load via require or use<br>
  :verbose triggers printing information about each load, alias, and refer<br>
<br>
  Example:<br>
<br>
  The following would load the libraries clojure.zip and clojure.set<br>
  abbreviated as &#39;s&#39;.<br>
<br>
  (require &#39;(clojure zip [set :as s]))</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3398">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="requiring-resolve">requiring-resolve</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(requiring-resolve sym)</code><code class="hide">^Var (requiring-resolve sym)</code></div>
</pre>
  <p class="var-docstr">Resolves namespace-qualified sym per &#39;resolve&#39;. If initial resolve<br>
  fails, attempts to require sym&#39;s namespace and retries.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3465">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="reset!">reset!</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(reset! atom newval)</code><code class="hide">(reset! ^Atom atom newval)</code></div>
</pre>
  <p class="var-docstr">Sets the value of atom to newval without regard for the<br>
  current value. Returns newval.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1454">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="reset-meta!">reset-meta!</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(reset-meta! ref metadata-map)</code><code class="hide">(reset-meta! ^Ref ref ^Map metadata-map)</code></div>
</pre>
  <p class="var-docstr">Atomically resets the metadata for a namespace/var/atom</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1478">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="reset-vals!">reset-vals!</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(reset-vals! atom newval)</code><code class="hide">^Vec (reset-vals! ^Atom atom newval)</code></div>
</pre>
  <p class="var-docstr">Sets the value of atom to newval. Returns [old new], the value of the<br>
  atom before and after the reset.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1461">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="resolve">resolve</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(resolve sym)</code><code class="hide">^Var (resolve ^Symbol sym)</code></div>
<div><code>(resolve env sym)</code><code class="hide">^Var (resolve ^Gettable env ^Symbol sym)</code></div>
</pre>
  <p class="var-docstr">Same as (ns-resolve *ns* sym) or (ns-resolve *ns* env sym)</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2460">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="rest">rest</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(rest coll)</code></div>
</pre>
  <p class="var-docstr">Returns a possibly empty seq of the items after the first. Calls seq on its<br>
         argument.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L58">source</a>
  
</li>
<li>
  <h3 class="Function" id="reverse">reverse</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(reverse coll)</code><code class="hide">^Collection (reverse ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">Returns a seq of the items in coll in reverse order. Not lazy.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L707">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="reversible?">reversible?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(reversible? coll)</code><code class="hide">^Boolean (reversible? coll)</code></div>
</pre>
  <p class="var-docstr">Returns true if coll implements Reversible</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3619">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="rseq">rseq</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(rseq rev)</code><code class="hide">^Seq (rseq ^Reversible rev)</code></div>
</pre>
  <p class="var-docstr">Returns, in constant time, a seq of the items in rev (which<br>
  can be a vector or sorted-map), in reverse order. If rev is empty returns nil.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1128">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="run!">run!</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(run! proc coll)</code><code class="hide">^Nil (run! ^Callable proc coll)</code></div>
</pre>
  <p class="var-docstr">Runs the supplied procedure (via reduce), for purposes of side<br>
  effects, on successive items in the collection. Returns nil.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4280">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="second">second</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(second x)</code></div>
</pre>
  <p class="var-docstr">Same as (first (next x))</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L77">source</a>
  
</li>
<li>
  <h3 class="Function" id="select-keys">select-keys</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(select-keys map keyseq)</code><code class="hide">^Map (select-keys ^Associative map ^Seqable keyseq)</code></div>
</pre>
  <p class="var-docstr">Returns a map containing only those entries in map whose key is in keys</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1092">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="seq">seq</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(seq coll)</code></div>
</pre>
  <p class="var-docstr">Returns a seq on the collection. If the collection is<br>
         empty, returns nil.  (seq nil) returns nil.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L104">source</a>
  
</li>
<li>
  <h3 class="Function" id="seq?">seq?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(seq? x)</code></div>
</pre>
  <p class="var-docstr">Returns true if x is a sequence</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L118">source</a>
  
</li>
<li>
  <h3 class="Function" id="seqable?">seqable?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(seqable? x)</code><code class="hide">^Boolean (seqable? x)</code></div>
</pre>
  <p class="var-docstr">Return true if the seq function is supported for x</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3586">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="sequence">sequence</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(sequence coll)</code><code class="hide">^Seq (sequence coll)</code></div>
</pre>
  <p class="var-docstr">Coerces coll to a (possibly empty) sequence, if it is not already<br>
  one. Will not force a lazy seq. (sequence nil) yields ()</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1571">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="sequential?">sequential?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(sequential? coll)</code><code class="hide">^Boolean (sequential? coll)</code></div>
</pre>
  <p class="var-docstr">Returns true if coll implements Sequential</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3609">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="set">set</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(set coll)</code><code class="hide">^MapSet (set ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">Returns a set of the distinct elements of coll.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2222">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="set?">set?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(set? x)</code><code class="hide">^Boolean (set? x)</code></div>
</pre>
  <p class="var-docstr">Returns true if x implements Set</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2217">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="shuffle">shuffle</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(shuffle coll)</code><code class="hide">^Vec (shuffle coll)</code></div>
</pre>
  <p class="var-docstr">Return a random permutation of coll</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4015">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="simple-ident?">simple-ident?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(simple-ident? x)</code><code class="hide">^Boolean (simple-ident? x)</code></div>
</pre>
  <p class="var-docstr">Return true if x is a symbol or keyword without a namespace</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1156">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="simple-keyword?">simple-keyword?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(simple-keyword? x)</code><code class="hide">^Boolean (simple-keyword? x)</code></div>
</pre>
  <p class="var-docstr">Return true if x is a keyword without a namespace</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1176">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="simple-symbol?">simple-symbol?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(simple-symbol? x)</code><code class="hide">^Boolean (simple-symbol? x)</code></div>
</pre>
  <p class="var-docstr">Return true if x is a symbol without a namespace</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1166">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="slurp">slurp</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(slurp f)</code><code class="hide">^String (slurp f)</code></div>
</pre>
  <p class="var-docstr">Opens file f and reads all its contents, returning a string.<br>
  f can be a string (filename) or a reader object like *in* or<br>
  the one returned by joker.os/open.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3933">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="some">some</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(some pred coll)</code><code class="hide">(some ^Callable pred ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">Returns the first logical true value of (pred x) for any x in coll,<br>
  else nil.  One common idiom is to use a set as pred, for example<br>
  this will return :fred if :fred is in the sequence, otherwise nil:<br>
  (some #{:fred} coll)</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1598">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Macro" id="some->">some-&gt;</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(some-&gt; expr &amp; forms)</code></div>
</pre>
  <p class="var-docstr">When expr is not nil, threads it into the first form (via -&gt;),<br>
  and when that result is not nil, through the next etc.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4232">source</a>
  
</li>
<li>
  <h3 class="Macro" id="some->>">some-&gt;&gt;</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(some-&gt;&gt; expr &amp; forms)</code></div>
</pre>
  <p class="var-docstr">When expr is not nil, threads it into the first form (via -&gt;&gt;),<br>
  and when that result is not nil, through the next etc.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4248">source</a>
  
</li>
<li>
  <h3 class="Function" id="some-fn">some-fn</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(some-fn p)</code><code class="hide">^Fn (some-fn ^Callable p)</code></div>
<div><code>(some-fn p1 p2)</code><code class="hide">^Fn (some-fn ^Callable p1 ^Callable p2)</code></div>
<div><code>(some-fn p1 p2 p3)</code><code class="hide">^Fn (some-fn ^Callable p1 ^Callable p2 ^Callable p3)</code></div>
<div><code>(some-fn p1 p2 p3 &amp; ps)</code><code class="hide">^Fn (some-fn ^Callable p1 ^Callable p2 ^Callable p3 &amp; ps)</code></div>
</pre>
  <p class="var-docstr">Takes a set of predicates and returns a function f that returns the first logical true value<br>
  returned by one of its composing predicates against any of its arguments, else it returns<br>
  logical false. Note that f is short-circuiting in that it will stop execution on the first<br>
  argument that triggers a logical true result against the original predicates.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4110">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="some?">some?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(some? x)</code></div>
</pre>
  <p class="var-docstr">Returns true if x is not nil, false otherwise.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L393">source</a>
  
</li>
<li>
  <h3 class="Function" id="sort">sort</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(sort coll)</code><code class="hide">^Seq (sort ^Seqable coll)</code></div>
<div><code>(sort comp coll)</code><code class="hide">^Seq (sort ^Comparator comp ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">Returns a sorted sequence of the items in coll. If no comparator is<br>
  supplied, uses compare.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1842">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="sort-by">sort-by</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(sort-by keyfn coll)</code><code class="hide">^Seq (sort-by ^Callable keyfn ^Seqable coll)</code></div>
<div><code>(sort-by keyfn comp coll)</code><code class="hide">^Seq (sort-by ^Callable keyfn ^Comparator comp ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">Returns a sorted sequence of the items in coll, where the sort<br>
  order is determined by comparing (keyfn item).  If no comparator is<br>
  supplied, uses compare.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1851">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="special-symbol?">special-symbol?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(special-symbol? s)</code><code class="hide">^Boolean (special-symbol? s)</code></div>
</pre>
  <p class="var-docstr">Returns true if s names a special form</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3005">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="spit">spit</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(spit f content &amp; options)</code><code class="hide">^Nil (spit f content &amp; options)</code></div>
</pre>
  <p class="var-docstr">Opposite of slurp.  Opens file f, writes content, then<br>
  closes f.<br>
  f can be a string (filename) or a writer object like *out* or<br>
  the one returned by joker.os/create.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3941">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="split-at">split-at</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(split-at n coll)</code><code class="hide">^Vec (split-at ^Number n ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">Returns a vector of [(take n coll) (drop n coll)]</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1739">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="split-with">split-with</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(split-with pred coll)</code><code class="hide">^Vec (split-with ^Callable pred ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">Returns a vector of [(take-while pred coll) (drop-while pred coll)]</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1745">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="splitv-at">splitv-at</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.5</span>
  <pre class="var-usage"><div><code>(splitv-at n coll)</code></div>
</pre>
  <p class="var-docstr">Returns a vector of [(into [] (take n coll)) (drop n coll)]</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4642">source</a>
  
</li>
<li>
  <h3 class="Function" id="str">str</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(str &amp; xs)</code></div>
</pre>
  <p class="var-docstr">With no args, returns the empty string. With one arg x, returns<br>
         string representation of x. (str nil) returns the empty string. With more than<br>
         one arg, returns the concatenation of the str values of the args.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L399">source</a>
  
</li>
<li>
  <h3 class="Function" id="string?">string?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(string? x)</code></div>
</pre>
  <p class="var-docstr">Returns true if x is a String</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L128">source</a>
  
</li>
<li>
  <h3 class="Function" id="subs">subs</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(subs s start)</code><code class="hide">^String (subs ^String s ^Number start)</code></div>
<div><code>(subs s start end)</code><code class="hide">^String (subs ^String s ^Number start ^Number end)</code></div>
</pre>
  <p class="var-docstr">Returns the substring of s beginning at start inclusive, and ending<br>
  at end (defaults to length of string), exclusive.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3016">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="subvec">subvec</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(subvec v start)</code><code class="hide">^Vec (subvec ^Vec v ^Number start)</code></div>
<div><code>(subvec v start end)</code><code class="hide">^Vec (subvec ^Vec v ^Number start ^Number end)</code></div>
</pre>
  <p class="var-docstr">Returns a persistent vector of the items in vector from<br>
  start (inclusive) to end (exclusive).  If end is not supplied,<br>
  defaults to (count vector). This operation is O(1) and very fast, as<br>
  the resulting vector shares structure with the original and no<br>
  trimming is done.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2157">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="swap!">swap!</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(swap! atom f &amp; args)</code><code class="hide">(swap! ^Atom atom ^Callable f &amp; args)</code></div>
</pre>
  <p class="var-docstr">Atomically swaps the value of atom to be:<br>
  (apply f current-value-of-atom args).<br>
  Returns the value that was swapped in.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1437">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="swap-vals!">swap-vals!</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(swap-vals! atom f &amp; args)</code><code class="hide">^Vec (swap-vals! ^Atom atom ^Callable f &amp; args)</code></div>
</pre>
  <p class="var-docstr">Atomically swaps the value of atom to be:<br>
  (apply f current-value-of-atom args). Note that f may be called<br>
  multiple times, and thus should be free of side effects.<br>
  Returns [old new], the value of the atom before and after the swap.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1445">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="symbol">symbol</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(symbol name)</code><code class="hide">^Symbol (symbol name)</code></div>
<div><code>(symbol ns name)</code><code class="hide">^Symbol (symbol ns name)</code></div>
</pre>
  <p class="var-docstr">Returns a Symbol with the given namespace and name.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L417">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="symbol?">symbol?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(symbol? x)</code><code class="hide">^Boolean (symbol? x)</code></div>
</pre>
  <p class="var-docstr">Return true if x is a Symbol</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L407">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="take">take</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(take n coll)</code><code class="hide">^Seq (take ^Number n ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">Returns a lazy sequence of the first n items in coll, or all items if<br>
  there are fewer than n.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1672">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="take-last">take-last</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(take-last n coll)</code><code class="hide">^Seq (take-last ^Number n ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">Returns a seq of the last n items in coll.  Depending on the type<br>
  of coll may be no better than linear time.  For vectors, see also subvec.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1709">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="take-nth">take-nth</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(take-nth n coll)</code><code class="hide">^Seq (take-nth ^Number n ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">Returns a lazy seq of every nth item in coll.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2422">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="take-while">take-while</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(take-while pred coll)</code><code class="hide">^Seq (take-while ^Callable pred ^Seqable coll)</code></div>
</pre>
  <p class="var-docstr">Returns a lazy sequence of successive items from coll while<br>
  (pred item) returns true. pred must be free of side-effects.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1682">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="test">test</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(test v)</code><code class="hide">^Keyword (test v)</code></div>
</pre>
  <p class="var-docstr">test [v] finds fn at key :test in var metadata and calls it,<br>
  presuming failure will throw exception</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2910">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="the-ns">the-ns</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(the-ns x)</code><code class="hide">^Namespace (the-ns x)</code></div>
</pre>
  <p class="var-docstr">If passed a namespace, returns it. Else, when passed a symbol,<br>
  returns the namespace named by it, throwing an exception if not<br>
  found.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2262">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Macro" id="time">time</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(time expr)</code></div>
</pre>
  <p class="var-docstr">Evaluates expr and prints the time it took.  Returns the value of expr.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2184">source</a>
  
</li>
<li>
  <h3 class="Function" id="trampoline">trampoline</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(trampoline f)</code><code class="hide">(trampoline ^Callable f)</code></div>
<div><code>(trampoline f &amp; args)</code><code class="hide">(trampoline ^Callable f &amp; args)</code></div>
</pre>
  <p class="var-docstr">trampoline can be used to convert algorithms requiring mutual<br>
  recursion without stack consumption. Calls f with supplied args, if<br>
  any. If f returns a fn, calls that fn with no arguments, and<br>
  continues to repeat, until the return value is not a fn, then<br>
  returns that non-fn value. Note that if you want to return a fn as a<br>
  final value, you must wrap it in some data structure and unpack it<br>
  after trampoline returns.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3645">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="tree-seq">tree-seq</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(tree-seq branch? children root)</code><code class="hide">^Seq (tree-seq ^Callable branch? ^Callable children root)</code></div>
</pre>
  <p class="var-docstr">Returns a lazy sequence of the nodes in a tree, via a depth-first walk.<br>
  branch? must be a fn of one arg that returns true if passed a node<br>
  that can have children (but may not).  children must be a fn of one<br>
  arg that returns a sequence of the children. Will only be called on<br>
  nodes for which branch? returns true. Root is the root node of the<br>
  tree.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2970">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="true?">true?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(true? x)</code></div>
</pre>
  <p class="var-docstr">Returns true if x is the value true, false otherwise.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L369">source</a>
  
</li>
<li>
  <h3 class="Function" id="type">type</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(type x)</code><code class="hide">^Type (type x)</code></div>
</pre>
  <p class="var-docstr">Returns the :type metadata of x, or its Type if none</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1320">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="unsigned-bit-shift-right">unsigned-bit-shift-right</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(unsigned-bit-shift-right x n)</code><code class="hide">^Int (unsigned-bit-shift-right ^Int x ^Int n)</code></div>
</pre>
  <p class="var-docstr">Bitwise shift right, without sign-extension.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L947">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="update">update</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(update m k f)</code><code class="hide">^Map (update ^Associative m k ^Callable f)</code></div>
<div><code>(update m k f x)</code><code class="hide">^Map (update ^Associative m k ^Callable f x)</code></div>
<div><code>(update m k f x y)</code><code class="hide">^Map (update ^Associative m k ^Callable f x y)</code></div>
<div><code>(update m k f x y z)</code><code class="hide">^Map (update ^Associative m k ^Callable f x y z)</code></div>
<div><code>(update m k f x y z &amp; more)</code><code class="hide">^Map (update ^Associative m k ^Callable f x y z &amp; more)</code></div>
</pre>
  <p class="var-docstr">&#39;Updates&#39; a value in an associative structure, where k is a<br>
  key and f is a function that will take the old value<br>
  and any supplied args and return the new value, and returns a new<br>
  structure.  If the key does not exist, nil is passed as the old value.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3559">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="update-in">update-in</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(update-in m ks f &amp; args)</code><code class="hide">^Map (update-in ^Associative m ^Seqable ks ^Callable f &amp; args)</code></div>
</pre>
  <p class="var-docstr">&#39;Updates&#39; a value in a nested associative structure, where ks is a<br>
  sequence of keys and f is a function that will take the old value<br>
  and any supplied args and return the new value, and returns a new<br>
  nested structure.  If any levels do not exist, hash-maps will be<br>
  created.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3546">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="update-keys">update-keys</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.1</span>
  <pre class="var-usage"><div><code>(update-keys m f)</code><code class="hide">^Map (update-keys m ^Callable f)</code></div>
</pre>
  <p class="var-docstr">m f =&gt; {(f k) v ...}<br>
  Given a map m and a function f of 1-argument, returns a new map whose<br>
  keys are the result of applying f to the keys of m, mapped to the<br>
  corresponding values of m.<br>
  f must return a unique key for each key of m, else the behavior is undefined.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4293">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="update-vals">update-vals</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.1</span>
  <pre class="var-usage"><div><code>(update-vals m f)</code><code class="hide">^Map (update-vals m ^Callable f)</code></div>
</pre>
  <p class="var-docstr">m f =&gt; {k (f v) ...}<br>
  Given a map m and a function f of 1-argument, returns a new map where the keys of m<br>
  are mapped to result of applying f to the corresponding values of m.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L4305">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="use">use</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(use &amp; args)</code><code class="hide">^Nil (use &amp; args)</code></div>
</pre>
  <p class="var-docstr">Like &#39;require, but also refers to each lib&#39;s namespace using<br>
  joker.core/refer. Use :use in the ns macro in preference to calling<br>
  this directly.<br>
<br>
  &#39;use accepts additional options in libspecs: :exclude, :only, :rename.<br>
  The arguments and semantics for :exclude, :only, and :rename are the same<br>
  as those documented for joker.core/refer.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3476">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="val">val</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(val e)</code></div>
</pre>
  <p class="var-docstr">Returns the value in the map entry.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1122">source</a>
  
</li>
<li>
  <h3 class="Function" id="vals">vals</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(vals map)</code><code class="hide">^Seq (vals ^Map map)</code></div>
</pre>
  <p class="var-docstr">Returns a sequence of the map&#39;s values, in the same order as (seq map).</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1111">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="var-get">var-get</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(var-get x)</code><code class="hide">(var-get ^Var x)</code></div>
</pre>
  <p class="var-docstr">Gets the value in the var object</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1346">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="var-set">var-set</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(var-set x val)</code><code class="hide">(var-set ^Var x val)</code></div>
</pre>
  <p class="var-docstr">Sets the value in the var object to val.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1351">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="var?">var?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(var? v)</code><code class="hide">^Boolean (var? v)</code></div>
</pre>
  <p class="var-docstr">Returns true if v is of type Var</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3011">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="vary-meta">vary-meta</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(vary-meta obj f &amp; args)</code><code class="hide">(vary-meta obj ^Callable f &amp; args)</code></div>
</pre>
  <p class="var-docstr">Returns an object of the same type and value as obj, with<br>
  (apply f (meta obj) args) as its metadata.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L496">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="vec">vec</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(vec coll)</code></div>
</pre>
  <p class="var-docstr">Creates a new vector containing the contents of coll.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L267">source</a>
  
</li>
<li>
  <h3 class="Function" id="vector">vector</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(vector &amp; args)</code><code class="hide">^Vec (vector &amp; args)</code></div>
</pre>
  <p class="var-docstr">Creates a new vector containing the args.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L273">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="vector?">vector?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(vector? x)</code></div>
</pre>
  <p class="var-docstr">Returns true if x is a vector</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L138">source</a>
  
</li>
<li>
  <h3 class="Macro" id="when">when</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(when test &amp; body)</code></div>
</pre>
  <p class="var-docstr">Evaluates test. If logical true, evaluates body in an implicit do.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L345">source</a>
  
</li>
<li>
  <h3 class="Macro" id="when-first">when-first</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(when-first bindings &amp; body)</code></div>
</pre>
  <p class="var-docstr">bindings =&gt; x xs<br>
<br>
  Roughly the same as (when (seq xs) (let [x (first xs)] body)) but xs is evaluated only once</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2711">source</a>
  
</li>
<li>
  <h3 class="Macro" id="when-let">when-let</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(when-let bindings &amp; body)</code></div>
</pre>
  <p class="var-docstr">bindings =&gt; binding-form test<br>
<br>
  When test is true, evaluates body with binding-form bound to the value of test</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1261">source</a>
  
</li>
<li>
  <h3 class="Macro" id="when-not">when-not</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(when-not test &amp; body)</code></div>
</pre>
  <p class="var-docstr">Evaluates test. If logical false, evaluates body in an implicit do.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L354">source</a>
  
</li>
<li>
  <h3 class="Macro" id="when-some">when-some</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(when-some bindings &amp; body)</code></div>
</pre>
  <p class="var-docstr">bindings =&gt; binding-form test<br>
<br>
  When test is not nil, evaluates body with binding-form bound to the<br>
  value of test</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1297">source</a>
  
</li>
<li>
  <h3 class="Macro" id="while">while</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(while test &amp; body)</code></div>
</pre>
  <p class="var-docstr">Repeatedly executes body while test expression is true. Presumes<br>
  some side-effect will cause test to become false/nil. Returns nil</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L3662">source</a>
  
</li>
<li>
  <h3 class="Macro" id="with-bindings">with-bindings</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(with-bindings binding-map &amp; body)</code></div>
</pre>
  <p class="var-docstr">Takes a map of Var/value pairs. Sets the vars to the corresponding values.<br>
  Then executes body. Resets the vars back to the original<br>
  values after body was evaluated. Returns the value of body.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1382">source</a>
  
</li>
<li>
  <h3 class="Function" id="with-bindings*">with-bindings*</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(with-bindings* binding-map f &amp; args)</code><code class="hide">(with-bindings* ^Map binding-map ^Callable f &amp; args)</code></div>
</pre>
  <p class="var-docstr">Takes a map of Var/value pairs. Sets the vars to the corresponding values.<br>
  Then calls f with the supplied arguments. Resets the vars back to the original<br>
  values after f returned. Returns whatever f returns.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1365">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Macro" id="with-in-str">with-in-str</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(with-in-str s &amp; body)</code></div>
</pre>
  <p class="var-docstr">Evaluates body in a context in which *in* is bound to a fresh<br>
  Buffer initialized with the string s.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2799">source</a>
  
</li>
<li>
  <h3 class="Function" id="with-meta">with-meta</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(with-meta obj m)</code></div>
</pre>
  <p class="var-docstr">Returns an object of the same type and value as obj, with<br>
         map m as its metadata.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L171">source</a>
  
</li>
<li>
  <h3 class="Macro" id="with-out-str">with-out-str</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(with-out-str &amp; body)</code></div>
</pre>
  <p class="var-docstr">Evaluates exprs in a context in which *out* is bound to a fresh<br>
  Buffer.  Returns the string created by any nested printing<br>
  calls.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2789">source</a>
  
</li>
<li>
  <h3 class="Macro" id="with-redefs">with-redefs</h3>
  <span class="var-kind Macro">Macro</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(with-redefs bindings &amp; body)</code></div>
</pre>
  <p class="var-docstr">The same as binding</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1411">source</a>
  
</li>
<li>
  <h3 class="Function" id="with-redefs-fn">with-redefs-fn</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(with-redefs-fn binding-map f &amp; args)</code></div>
</pre>
  <p class="var-docstr">The same as with-bindings*</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1377">source</a>
  
</li>
<li>
  <h3 class="Function" id="xml-seq">xml-seq</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(xml-seq root)</code><code class="hide">^Seq (xml-seq root)</code></div>
</pre>
  <p class="var-docstr">A tree seq on the xml elements as per xml/parse</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L2996">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="zero?">zero?</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(zero? x)</code><code class="hide">^Boolean (zero? ^Number x)</code></div>
</pre>
  <p class="var-docstr">Returns true if x is zero, else false</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L629">source</a>
  <a href="#" class="types">show types</a>
</li>
<li>
  <h3 class="Function" id="zipmap">zipmap</h3>
  <span class="var-kind Function">Function</span>
  <span class="var-added">v1.0</span>
  <pre class="var-usage"><div><code>(zipmap keys vals)</code><code class="hide">^Map (zipmap ^Seqable keys ^Seqable vals)</code></div>
</pre>
  <p class="var-docstr">Returns a map with the keys mapped to the corresponding vals.</p>
  <a href="https://github.com/candid82/joker/blob/master/core/data/core.joke#L1807">source</a>
  <a href="#" class="types">show types</a>
</li>

    </ul>
  </div>
</body>
<script src="main.js"></script>
</html>
